import { thrownErrorMessage } from "@t3tools/client-runtime/errors"; import { AuthOrchestrationOperateScope, AuthSettingsWriteScope, type EnvironmentId, type ProjectScript, type ProjectScriptIcon, type ResolvedKeybindingsConfig, } from "@t3tools/contracts"; import { isAtomCommandInterrupted, squashAtomCommandFailure, type AtomCommandResult, } from "@t3tools/client-runtime/state/runtime"; import { BugIcon, FlaskConicalIcon, HammerIcon, ListChecksIcon, PlayIcon, WrenchIcon, } from "lucide-react"; import { msg, T, useGT, useMessages, Var } from "gt-react"; import React, { type FormEvent, type KeyboardEvent, useEffect, useRef, useState } from "react"; import { keybindingValueForCommand, decodeProjectScriptKeybindingRule, } from "~/lib/projectScriptKeybindings"; import { keybindingFromKeyboardEvent } from "~/components/settings/KeybindingsSettings.logic"; import { commandForProjectScript, nextProjectScriptId } from "~/projectScripts"; import { readEnvironmentScope, useEnvironmentScope } from "~/state/session"; import { useComposerMenuState } from "./chat/useComposerMenuState"; import { AlertDialog, AlertDialogClose, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogPopup, AlertDialogTitle, } from "./ui/alert-dialog"; import { Button } from "./ui/button"; import { Dialog, DialogDescription, DialogFooter, DialogHeader, DialogPanel, DialogPopup, DialogTitle, } from "./ui/dialog"; import { Input } from "./ui/input"; import { Label } from "./ui/label"; import { Popover, PopoverPopup, PopoverTrigger } from "./ui/popover"; import { Switch } from "./ui/switch"; import { Textarea } from "./ui/textarea"; const SCRIPT_ICONS: Array<{ id: ProjectScriptIcon; label: string }> = [ { id: "play", label: msg("Play") }, { id: "test", label: msg("Test") }, { id: "lint", label: msg("Lint") }, { id: "configure", label: msg("Configure") }, { id: "build", label: msg("Build") }, { id: "debug", label: msg("Debug") }, ]; export function ScriptIcon({ icon, className = "size-3.5", }: { icon: ProjectScriptIcon; className?: string; }) { if (icon === "test") return ; if (icon === "lint") return ; if (icon === "configure") return ; if (icon === "build") return ; if (icon === "debug") return ; return ; } export interface NewProjectScriptInput { name: string; command: string; icon: ProjectScriptIcon; runOnWorktreeCreate: boolean; waitForSetup: boolean; runOnSettle: boolean; stopOnSettle?: boolean; /** Omit to preserve the current shortcut when the form did not edit it. */ keybinding?: string | null; previewUrl: string | null; autoOpenPreview: boolean; } export type ProjectScriptActionResult = AtomCommandResult; export const EMPTY_PROJECT_SCRIPT_INPUT: NewProjectScriptInput = { name: "", command: "", icon: "play", runOnWorktreeCreate: false, waitForSetup: false, runOnSettle: false, stopOnSettle: false, keybinding: null, previewUrl: null, autoOpenPreview: false, }; export interface ProjectScriptEditorRequest { scriptId: string | null; initial: NewProjectScriptInput; error?: string; } export function editorRequestForScript( script: ProjectScript, keybindings: ResolvedKeybindingsConfig, ): ProjectScriptEditorRequest { return { scriptId: script.id, initial: { name: script.name, command: script.command, icon: script.icon, runOnWorktreeCreate: script.runOnWorktreeCreate, waitForSetup: script.runOnWorktreeCreate && script.async === false, runOnSettle: script.runOnSettle ?? false, stopOnSettle: script.stopOnSettle ?? false, keybinding: keybindingValueForCommand(keybindings, commandForProjectScript(script.id)), previewUrl: script.previewUrl ?? null, autoOpenPreview: script.autoOpenPreview ?? false, }, }; } export function ProjectScriptEditorDialog({ environmentId, editScope = AuthOrchestrationOperateScope, request, scripts, onSubmit, onDelete, onClose, }: { environmentId: EnvironmentId; editScope?: typeof AuthOrchestrationOperateScope | typeof AuthSettingsWriteScope; request: ProjectScriptEditorRequest | null; scripts: ReadonlyArray; onSubmit: ( scriptId: string | null, input: NewProjectScriptInput, ) => Promise; onDelete: (scriptId: string) => void; onClose: () => void; }) { const gt = useGT(); const canEditActions = useEnvironmentScope(environmentId, editScope); // Scope errors by request so late saves cannot overwrite a newer request's error. const [errorState, setErrorState] = useState<{ readonly request: ProjectScriptEditorRequest; readonly message: string | null; } | null>(null); const validationError = request === null ? null : errorState?.request === request ? errorState.message : (request.error ?? null); const setValidationError = (message: string | null) => { if (request !== null) setErrorState({ request, message }); }; // The last opened request stays shown while the dialog animates closed. Each // new request mounts a fresh form, which drops the previous request's save. const [shown, setShown] = useState<{ readonly request: ProjectScriptEditorRequest; readonly key: number; } | null>(request === null ? null : { request, key: 0 }); if (request !== null && request !== shown?.request) { setShown({ request, key: (shown?.key ?? 0) + 1 }); } const [deleteConfirmOpen, setDeleteConfirmOpen] = useComposerMenuState(!canEditActions); const [deleteName, setDeleteName] = useState(""); return ( <> { if (!open) onClose(); }} > {/* The form owns its fields so a keystroke re-renders it, not the dialog chrome. */} {shown ? ( { setDeleteName(name); setDeleteConfirmOpen(true); }} onClose={onClose} /> ) : null} Delete action "{deleteName}"? This action cannot be undone. }> Cancel { if (!request?.scriptId) return; if (!readEnvironmentScope(environmentId, editScope)) { setValidationError(gt("This connection cannot change project actions.")); return; } setDeleteConfirmOpen(false); onClose(); onDelete(request.scriptId); }} > Delete action > ); } function ProjectScriptEditorForm({ environmentId, editScope, request, scripts, validationError, onValidationError: setValidationError, onSubmit, onRequestDelete, onClose, }: { environmentId: EnvironmentId; editScope: typeof AuthOrchestrationOperateScope | typeof AuthSettingsWriteScope; request: ProjectScriptEditorRequest; scripts: ReadonlyArray; validationError: string | null; onValidationError: (error: string | null) => void; onSubmit: ( scriptId: string | null, input: NewProjectScriptInput, ) => Promise; onRequestDelete: (name: string) => void; onClose: () => void; }) { const gt = useGT(); const m = useMessages(); const canEditActions = useEnvironmentScope(environmentId, editScope); const canWriteSettings = useEnvironmentScope(environmentId, AuthSettingsWriteScope); const formId = React.useId(); const [name, setName] = useState(request.initial.name); const [command, setCommand] = useState(request.initial.command); const [icon, setIcon] = useState(request.initial.icon); const [iconPickerOpen, setIconPickerOpen] = useComposerMenuState(!canEditActions); const [runOnWorktreeCreate, setRunOnWorktreeCreate] = useState( request.initial.runOnWorktreeCreate, ); const [waitForSetup, setWaitForSetup] = useState(request.initial.waitForSetup); const [runOnSettle, setRunOnSettle] = useState(request.initial.runOnSettle); const [stopOnSettle, setStopOnSettle] = useState(request.initial.stopOnSettle ?? false); const [keybinding, setKeybinding] = useState(request.initial.keybinding ?? ""); const [previewUrl, setPreviewUrl] = useState(request.initial.previewUrl ?? ""); const [autoOpenPreview, setAutoOpenPreview] = useState(request.initial.autoOpenPreview); const [isSaving, setIsSaving] = useState(false); const pendingSubmissionRef = useRef(null); // A save that settles after this form is replaced must not close or error // the request that replaced it. // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- drops the pending save on unmount so a late result cannot close or fail the next request useEffect( () => () => { pendingSubmissionRef.current = null; }, [], ); const isEditing = request.scriptId != null; const close = () => { pendingSubmissionRef.current = null; setIsSaving(false); setIconPickerOpen(false); onClose(); }; const captureKeybinding = (event: KeyboardEvent) => { if (!readEnvironmentScope(environmentId, editScope)) return; if (!readEnvironmentScope(environmentId, AuthSettingsWriteScope)) return; if (event.key === "Tab") return; event.preventDefault(); if (event.key === "Backspace" || event.key === "Delete") { setKeybinding(""); return; } const next = keybindingFromKeyboardEvent(event, navigator.platform); if (!next) return; setKeybinding(next); }; const submit = async (event: FormEvent) => { event.preventDefault(); if (pendingSubmissionRef.current !== null) return; if (!readEnvironmentScope(environmentId, editScope)) { setValidationError(gt("This connection cannot change project actions.")); return; } const changesKeybinding = (keybinding.trim() || null) !== (request.initial.keybinding?.trim() || null); const canChangeKeybinding = readEnvironmentScope(environmentId, AuthSettingsWriteScope); if (changesKeybinding && !canChangeKeybinding) { setValidationError(gt("This connection cannot change keyboard shortcuts.")); return; } const trimmedName = name.trim(); const trimmedCommand = command.trim(); if (trimmedName.length === 0) { setValidationError(gt("Name is required.")); return; } if (trimmedCommand.length === 0) { setValidationError(gt("Command is required.")); return; } setValidationError(null); let payload: NewProjectScriptInput; try { const scriptIdForValidation = request.scriptId ?? nextProjectScriptId( trimmedName, scripts.map((script) => script.id), ); const keybindingRule = decodeProjectScriptKeybindingRule({ keybinding, command: commandForProjectScript(scriptIdForValidation), }); const trimmedPreviewUrl = previewUrl.trim(); payload = { name: trimmedName, command: trimmedCommand, icon, runOnWorktreeCreate, waitForSetup: runOnWorktreeCreate && waitForSetup, runOnSettle, stopOnSettle, ...((request.scriptId === null && canChangeKeybinding) || changesKeybinding ? { keybinding: keybindingRule?.key ?? null } : {}), previewUrl: trimmedPreviewUrl.length > 0 ? trimmedPreviewUrl : null, autoOpenPreview: trimmedPreviewUrl.length > 0 ? autoOpenPreview : false, } satisfies NewProjectScriptInput; } catch (error) { setValidationError(thrownErrorMessage(error, m) ?? gt("Failed to save action.")); return; } const submission = {}; pendingSubmissionRef.current = submission; setIsSaving(true); setIconPickerOpen(false); try { const result = await onSubmit(request.scriptId, payload); if (pendingSubmissionRef.current === submission) { if (result._tag === "Failure") { if (!isAtomCommandInterrupted(result)) { const error = squashAtomCommandFailure(result); setValidationError(thrownErrorMessage(error, m) ?? gt("Failed to save action.")); } } else { close(); } } } catch (error) { if (pendingSubmissionRef.current === submission) { setValidationError(thrownErrorMessage(error, m) ?? gt("Failed to save action.")); } } if (pendingSubmissionRef.current === submission) { pendingSubmissionRef.current = null; setIsSaving(false); } }; return ( <> {isEditing ? Edit Action : Add Action} Actions are project-scoped commands you can run from the top bar or keybindings. Name } > {SCRIPT_ICONS.map((entry) => { const isSelected = entry.id === icon; return ( { setIcon(entry.id); setIconPickerOpen(false); }} > {m(entry.label)} ); })} setName(event.target.value)} /> Keybinding Press a shortcut. Use Backspace to clear. Shortcuts are environment-wide. Projects using the same action share its shortcut. Command setCommand(event.target.value)} /> Preview URL (optional) setPreviewUrl(event.target.value)} /> Open this URL in the in-app preview when this action runs. Run automatically on worktree creation setRunOnWorktreeCreate(Boolean(checked))} /> Wait for it to finish before the agent starts setWaitForSetup(Boolean(checked))} /> Run in the thread's worktree when the thread settles setRunOnSettle(Boolean(checked))} /> Stop this action when the thread settles setStopOnSettle(Boolean(checked))} /> Open preview automatically when this action runs setAutoOpenPreview(Boolean(checked))} /> {validationError && {validationError}} {isEditing && ( onRequestDelete(name)} > Delete )} Cancel {isSaving ? Saving… : isEditing ? Save changes : Save action} > ); }
Press a shortcut. Use Backspace to clear. Shortcuts are environment-wide. Projects using the same action share its shortcut.
Backspace
Open this URL in the in-app preview when this action runs.
{validationError}