@duetso/agent 0.1.57 → 0.1.59

package/dist/src/tui/app.js

@@ -9,7 +9,7 @@ import { DUET_BANNER_LINES_COMPACT, historyDisplayBlocks, limitHistoryDisplayMes
 import { listRecentSessions } from "./recent-sessions.js";
 import { createSidebar, SIDEBAR_WIDTH } from "./sidebar.js";
 import { orderedSelectableStarters, selectStarters } from "./starters.js";
-import { COLORS, HINT_IDLE, HINT_RUNNING } from "./theme.js";
+import { COLORS, HINT_IDLE, HINT_RUNNING, HINT_SELECTION_COPY } from "./theme.js";
 // Re-exports preserve the historical `tui/app.js` entry point used by tests
 // and external callers; the implementations live in focused leaf modules.
 export { activeFileAutocompleteToken, activeSkillAutocompleteToken, fileAutocompleteMatches, formatQuestionOptionDescription, formatSkillAutocompleteDescription, moveQuestionOptionSelection, moveSkillAutocompleteSelection, questionPickerAnswerPayload, replaceFileAutocompleteToken, replaceSkillAutocompleteToken, skillAutocompleteMatches, } from "./autocomplete.js";
@@ -30,11 +30,17 @@ const QUESTION_OPTION_LIMIT = AUTOCOMPLETE_LIMITS.questionOption;
 export async function runTui(input) {
     const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
     // useMouse: true so the scroll wheel reaches the transcript
-    // ScrollBoxRenderable. Drag-select for native copy still works in every
-    // mainstream terminal by holding Option (macOS) or Shift (most Linux
-    // terminals) while dragging, which bypasses the terminal's mouse
-    // capture. PageUp/PageDown and Shift+Up/Down keyboard bindings below are
-    // the no-mouse fallback.
+    // ScrollBoxRenderable and so OpenTUI receives drag events for in-app
+    // text selection. Selected text is captured via the renderer's
+    // `selection` event below and copied to the clipboard via OSC 52 (or
+    // CLI fallback) on the platform-appropriate copy keystroke (Cmd+C on
+    // macOS, Ctrl+Shift+C elsewhere) or `/copy`. PageUp/PageDown and
+    // Shift+Up/Down keyboard bindings below cover terminals or sessions
+    // where the wheel does not reach us (e.g. tmux without mouse mode).
+    //
+    // Bare Ctrl+C remains the always-exit keystroke (handled via
+    // exitOnCtrlC) so the convention every other interactive Linux/Windows
+    // terminal app follows still works here.
     const renderer = await createCliRenderer({
         exitOnCtrlC: true,
         useMouse: true,
@@ -42,6 +48,17 @@ export async function runTui(input) {
         targetFps: 60,
     });
     restoreWindowGlobal(previousWindow);
+    // Most recent drag-selected text. OpenTUI emits the `selection` event
+    // whenever a drag finishes; we cache the resulting string so /copy and
+    // the copy keystroke can prefer the user's actual highlight over the
+    // last-message heuristic, and so the bottom hint can advertise the
+    // copy keystroke only while it actually does something.
+    let lastSelectionText = "";
+    renderer.on("selection", (selection) => {
+        lastSelectionText = selection.getSelectedText();
+        logSelectionDiag(lastSelectionText);
+        refreshHint();
+    });
     // Outer row wraps the main column and a right-side sidebar that surfaces
     // the runner's current todo list and state-machine progress.
     const root = new BoxRenderable(renderer, {
@@ -71,17 +88,22 @@ export async function runTui(input) {
         borderColor: COLORS.border,
         padding: 1,
     });
+    // Status and hint chrome are excluded from drag-select so a highlight that
+    // sweeps the bottom of the screen does not pull the spinner / hint text
+    // into the clipboard alongside the transcript content the user wanted.
     const status = new TextRenderable(renderer, {
         content: "",
         fg: COLORS.status,
         height: 1,
         flexShrink: 0,
+        selectable: false,
     });
     const hint = new TextRenderable(renderer, {
         content: HINT_IDLE,
         fg: COLORS.hint,
         height: 1,
         flexShrink: 0,
+        selectable: false,
     });
     const skillAutocompletePanel = new BoxRenderable(renderer, {
         flexDirection: "column",
@@ -99,11 +121,15 @@ export async function runTui(input) {
     // length so a one-line description doesn't leave an empty trailing line
     // beneath the name. The renderer sets `height` whenever it writes
     // `content`.
+    // Autocomplete and panel chrome are not part of the transcript content,
+    // so exclude them from drag-select to keep the clipboard focused on
+    // assistant/user messages.
     const makeItemRow = () => {
         const row = new TextRenderable(renderer, {
             content: "",
             fg: COLORS.hint,
             flexShrink: 0,
+            selectable: false,
         });
         row.visible = false;
         return row;
@@ -113,6 +139,7 @@ export async function runTui(input) {
         fg: COLORS.status,
         height: 1,
         flexShrink: 0,
+        selectable: false,
     });
     const commandHeader = makeHeaderRow("commands");
     const commandRows = Array.from({ length: BUILT_IN_SLASH_COMMANDS.length }, makeItemRow);
@@ -140,6 +167,7 @@ export async function runTui(input) {
         fg: COLORS.status,
         height: 1,
         flexShrink: 0,
+        selectable: false,
     });
     const fileAutocompleteRows = Array.from({ length: FILE_AUTOCOMPLETE_LIMIT }, () => {
         const row = new TextRenderable(renderer, {
@@ -147,6 +175,7 @@ export async function runTui(input) {
             fg: COLORS.hint,
             height: 1,
             flexShrink: 0,
+            selectable: false,
         });
         row.visible = false;
         return row;
@@ -169,11 +198,13 @@ export async function runTui(input) {
         fg: COLORS.agent,
         wrapMode: "word",
         flexShrink: 0,
+        selectable: false,
     });
     const questionSpacer = new TextRenderable(renderer, {
         content: "",
         height: 1,
         flexShrink: 0,
+        selectable: false,
     });
     const questionRows = Array.from({ length: QUESTION_OPTION_LIMIT }, () => {
         const row = new TextRenderable(renderer, {
@@ -181,6 +212,7 @@ export async function runTui(input) {
             fg: COLORS.hint,
             wrapMode: "word",
             flexShrink: 0,
+            selectable: false,
         });
         row.visible = false;
         return row;
@@ -198,10 +230,14 @@ export async function runTui(input) {
         paddingRight: 1,
         flexShrink: 0,
     });
+    // The leading "> " sigil is decoration, not content; excluding it from
+    // selection means a drag that starts at the input row does not pull the
+    // sigil into the clipboard alongside the highlighted text.
     const prompt = new TextRenderable(renderer, {
         content: "> ",
         fg: COLORS.user,
         width: 2,
+        selectable: false,
     });
     // Textarea (rather than Input) so long messages soft-wrap visually. Enter
     // is intercepted in onKeyDown below to submit instead of inserting a newline.
@@ -252,13 +288,21 @@ export async function runTui(input) {
     }
     function setHint(running) {
         const base = running ? HINT_RUNNING : HINT_IDLE;
-        hint.content = pendingImages.length > 0 ? `${attachmentHint()} · ${base}` : base;
+        const segments = [];
+        if (pendingImages.length > 0)
+            segments.push(attachmentHint());
+        segments.push(base);
+        if (lastSelectionText.trim().length > 0)
+            segments.push(HINT_SELECTION_COPY);
+        hint.content = segments.join(" · ");
     }
     function attachmentHint() {
         const n = pendingImages.length;
         return n === 1 ? "📎 1 image attached" : `📎 ${n} images attached`;
     }
-    function refreshAttachmentHint() {
+    // Single-channel hint refresh used by every input that affects what the
+    // bottom row should advertise (running state, attachments, selection).
+    function refreshHint() {
         setHint(running);
     }
     // ---- runtime state ---------------------------------------------------------
@@ -272,7 +316,7 @@ export async function runTui(input) {
     let nextImageId = 1;
     // Parallel record of user/agent message bodies driven by the same code
     // paths that render them into the transcript. The `/copy` slash command
-    // and Ctrl+Y keystroke read from this log instead of trying to walk the
+    // and copy keystroke read from this log instead of trying to walk the
     // ScrollBoxRenderable, which only stores presentation lines.
     const transcriptLog = [];
     function recordTranscriptEntry(kind, text) {
@@ -850,29 +894,6 @@ export async function runTui(input) {
     let pendingQuestions = [];
     let questionOptionSelectedIndex = 0;
     let suppressNextEscapeExit = false;
-    let closingAfterInterrupt = false;
-    const requestExit = async () => {
-        if (running) {
-            if (closingAfterInterrupt)
-                return;
-            closingAfterInterrupt = true;
-            stopWorkingTicker();
-            setStatus("● interrupting…");
-            try {
-                await input.session.interrupt();
-                await input.session.waitForTerminal();
-            }
-            catch (error) {
-                reportError(error);
-            }
-            finally {
-                renderer.destroy();
-            }
-        }
-        else {
-            renderer.destroy();
-        }
-    };
     function skillAutocompleteIsOpen() {
         return Boolean(skillAutocompleteToken && skillAutocompleteItems.length > 0);
     }
@@ -1126,6 +1147,14 @@ export async function runTui(input) {
     }
     const keyHandler = renderer._keyHandler;
     keyHandler.onInternal("keypress", (key) => {
+        logKeyDiag("global", key);
+        // Copy keystroke. Lives on the global handler (not
+        // inputField.onKeyDown) because the mousedown that starts a
+        // drag-select moves focus off the textarea — the focused-renderable
+        // path stops firing right when the user has something to copy. The
+        // global handler always fires regardless of focus.
+        if (handleCopyKeystroke(key))
+            return;
         if (key.name !== "escape")
             return;
         if (suppressNextEscapeExit) {
@@ -1149,7 +1178,7 @@ export async function runTui(input) {
             return;
         }
         key.preventDefault();
-        void requestExit();
+        handleEscape();
     });
     // Keyboard scroll bindings for the transcript. Mirrors the mouse wheel
     // for terminals that swallow mouse events (tmux without mouse mode, ssh
@@ -1168,6 +1197,7 @@ export async function runTui(input) {
     // consumes escape via its own keybindings before any global keypress handler
     // fires, so we intercept at the Renderable's onKeyDown hook which runs first.
     inputField.onKeyDown = (key) => {
+        logKeyDiag("keydown", key);
         if (key.name === "pageup") {
             scrollTranscriptByPage(-1);
             key.preventDefault();
@@ -1232,15 +1262,6 @@ export async function runTui(input) {
             void triggerClipboardProbe("keystroke");
             return;
         }
-        // Ctrl+Y — emacs-style "yank," repurposed here as the keyboard hotkey
-        // for the `/copy` slash command. macOS Cmd+C is owned by the terminal
-        // emulator and never reaches the TUI, so Ctrl+Y is the closest thing
-        // to a real copy keystroke we can deliver across all terminals.
-        if (key.name === "y" && key.ctrl && !key.shift && !key.super && !key.meta) {
-            key.preventDefault();
-            void handleCopySlashCommand("/copy");
-            return;
-        }
         if (skillAutocompleteIsOpen()) {
             if (key.name === "up") {
                 skillAutocompleteSelectedIndex = moveSkillAutocompleteSelection(skillAutocompleteSelectedIndex, skillAutocompleteItems.length, -1);
@@ -1335,10 +1356,88 @@ export async function runTui(input) {
             return;
         }
         if (key.name === "escape") {
-            void requestExit();
+            handleEscape();
             return;
         }
     };
+    // Esc interrupts the in-flight turn; when nothing is running it is a
+    // no-op so muscle memory does not eject the user out of the session.
+    // Quitting goes through Ctrl+C (renderer's exitOnCtrlC) or closing the
+    // terminal — both paths drain through the `finally` block in
+    // cli/run.ts that disposes the SessionManager and flushes PGlite.
+    function handleEscape() {
+        if (!running)
+            return;
+        void input.session.interrupt().catch(reportError);
+    }
+    // ---- /diag diagnostics -----------------------------------------------------
+    // `/diag` toggles a key+selection event log so the user can show us
+    // exactly what their terminal forwards when something silently fails
+    // (e.g. a keystroke not reaching the handler, a selection event firing
+    // with empty text). Kept as a flag rather than a one-shot capture so
+    // we can layer additional diagnostic facets on the same surface
+    // without inventing new commands every time.
+    let keyDiagnostics = false;
+    function handleDiagSlashCommand(raw) {
+        const argument = raw === "/diag" ? "" : raw.slice("/diag ".length).trim();
+        if (argument === "" || argument === "keys") {
+            keyDiagnostics = !keyDiagnostics;
+            appendBlock("[diag]", keyDiagnostics
+                ? "key + selection event logging ON. Run /diag again to stop."
+                : "key + selection event logging OFF.", COLORS.system);
+            return;
+        }
+        appendBlock("[diag]", "Usage: /diag (or /diag keys) — toggles key + selection event logging", COLORS.system);
+    }
+    function logKeyDiag(label, key) {
+        if (!keyDiagnostics)
+            return;
+        const flags = [];
+        if (key.ctrl)
+            flags.push("ctrl");
+        if (key.shift)
+            flags.push("shift");
+        if (key.meta)
+            flags.push("meta");
+        if (key.super)
+            flags.push("super");
+        if (key.option)
+            flags.push("option");
+        appendBlock("[diag]", `${label} name=${JSON.stringify(key.name)} flags=[${flags.join(",")}] sequence=${JSON.stringify(key.sequence)} source=${key.source} | lastSelection=${lastSelectionText.length}c rendererSel=${renderer.hasSelection ? "yes" : "no"}`, COLORS.hint);
+    }
+    function logSelectionDiag(text) {
+        if (!keyDiagnostics)
+            return;
+        appendBlock("[diag]", `selection event: ${text.length} chars — ${JSON.stringify(text.slice(0, 80))}`, COLORS.hint);
+    }
+    /**
+     * Copy keystroke detection. Accepts Cmd+C, Cmd+Shift+C, and Ctrl+Shift+C
+     * because each mainstream terminal forwards a different subset — see
+     * `theme.ts` for which one ends up in the hint label per terminal.
+     * Returns true (and prevents default) when the keystroke matched and a
+     * non-empty selection was on the clipboard path; false otherwise so the
+     * caller can fall through to other handlers (Esc, etc.).
+     *
+     * Accepts both "c" and "C" as the key name because some kitty parsers
+     * report the shifted letter while others report the base letter with
+     * `shift: true`.
+     */
+    function handleCopyKeystroke(key) {
+        const isCopyLetter = key.name === "c" || key.name === "C";
+        if (!isCopyLetter)
+            return false;
+        const cmdHeld = key.super || key.meta;
+        const isCmdC = cmdHeld && !key.shift && !key.ctrl;
+        const isCmdShiftC = cmdHeld && key.shift && !key.ctrl;
+        const isCtrlShiftC = key.ctrl && key.shift && !cmdHeld;
+        if (!(isCmdC || isCmdShiftC || isCtrlShiftC))
+            return false;
+        if (lastSelectionText.trim().length === 0)
+            return false;
+        key.preventDefault();
+        void copyActiveSelection();
+        return true;
+    }
     inputField.onContentChange = () => {
         // First real keystroke into the input collapses the starter section
         // — the user is composing their own prompt, so the suggestions get
@@ -1405,7 +1504,7 @@ export async function runTui(input) {
                 pendingImages.push(pending);
                 inputField.insertText(pending.label);
                 appendBlock("[paste]", `attached ${pending.label} from ${pending.path}`, COLORS.system);
-                refreshAttachmentHint();
+                refreshHint();
             }
             catch (error) {
                 // The clipboard looked like an image path but we could not load
@@ -1445,7 +1544,7 @@ export async function runTui(input) {
             pendingImages.push(pending);
             inputField.insertText(pending.label);
             appendBlock("[paste]", `attached ${pending.label} (${mimeType}, ${formatBytes(bytes.length)})`, COLORS.system);
-            refreshAttachmentHint();
+            refreshHint();
         }
         catch (error) {
             appendBlock("[paste]", error instanceof Error ? error.message : String(error), COLORS.error);
@@ -1456,7 +1555,7 @@ export async function runTui(input) {
             return;
         pendingImages = [];
         nextImageId = 1;
-        refreshAttachmentHint();
+        refreshHint();
     }
     // Manual clipboard probe. Read the OS clipboard for an image right now and
     // attach it if found; otherwise emit a useful diagnostic line. Used both by
@@ -1516,6 +1615,10 @@ export async function runTui(input) {
             void handleCopySlashCommand(message);
             return;
         }
+        if (message === "/diag" || message.startsWith("/diag ")) {
+            handleDiagSlashCommand(message);
+            return;
+        }
         const submittedImages = pendingImages;
         recordTranscriptEntry("user", message);
         appendBlock("you:", message, COLORS.user);
@@ -1541,27 +1644,63 @@ export async function runTui(input) {
             markRunning();
         }
     }
+    /**
+     * Copy the active drag-selection to the clipboard and clear the highlight
+     * so the user gets visual confirmation the action happened. Used by the
+     * platform copy keystroke (Cmd+C on macOS, Ctrl+Shift+C elsewhere); the
+     * slash command path goes through `handleCopySlashCommand` so it can
+     * also serve `/copy last|all|<N>`.
+     */
+    async function copyActiveSelection() {
+        const text = lastSelectionText;
+        if (text.trim().length === 0)
+            return;
+        const result = await copyTextToClipboard(text);
+        renderer.clearSelection();
+        lastSelectionText = "";
+        refreshHint();
+        if (result.ok) {
+            appendBlock("[copy]", `copied selection (${text.length} char${text.length === 1 ? "" : "s"}) to clipboard via ${result.via}`, COLORS.system);
+        }
+        else {
+            appendBlock("[copy]", `clipboard write failed: ${result.error ?? "unknown error"}` +
+                (process.platform === "linux" ? "\nInstall one of: wl-clipboard, xclip, xsel" : ""), COLORS.error);
+        }
+    }
     /**
      * Resolve a `/copy ...` invocation to clipboard text and pipe it to the
-     * OS clipboard. Surfaces every failure mode in the transcript so users on
-     * minimal Linux installs see exactly which writer is missing (e.g.
-     * "install xclip or wl-clipboard").
+     * OS clipboard. When the user has an active drag-selection and ran a bare
+     * `/copy`, copy that highlight verbatim — it matches what they actually
+     * have on screen. Otherwise fall back to the transcript-log heuristic
+     * (`last` / `all` / `<N>`).
+     *
+     * Failures are surfaced in the transcript so users on minimal Linux
+     * installs see exactly which writer is missing.
      */
     async function handleCopySlashCommand(raw) {
         const argumentRaw = raw === "/copy" ? "" : raw.slice("/copy ".length);
         const argument = parseCopyArgument(argumentRaw);
         if (argument === undefined) {
-            appendBlock("[copy]", "Usage: /copy [last|all|<N>]  — last (default) copies the most recent agent reply", COLORS.system);
+            appendBlock("[copy]", "Usage: /copy [last|all|<N>]  — last (default) copies the most recent agent reply, " +
+                "or copies the active drag-selection when one is present", COLORS.system);
             return;
         }
-        const text = selectCopyText(transcriptLog, argument);
+        // A bare `/copy` (or the copy keystroke while a selection is active)
+        // prefers the drag-selection so the clipboard matches what the user
+        // has highlighted on screen; an explicit `/copy last|all|<N>` always
+        // uses the transcript log instead.
+        const explicitArgument = argumentRaw.trim().length > 0;
+        const useSelection = !explicitArgument && lastSelectionText.trim().length > 0;
+        const text = useSelection ? lastSelectionText : selectCopyText(transcriptLog, argument);
         if (!text) {
             appendBlock("[copy]", "nothing to copy yet", COLORS.system);
             return;
         }
-        const result = await writeClipboardText(text);
+        const result = await copyTextToClipboard(text);
         if (result.ok) {
-            const summary = describeCopySelection(argument, text.length);
+            const summary = useSelection
+                ? `selection (${text.length} char${text.length === 1 ? "" : "s"})`
+                : describeCopySelection(argument, text.length);
             appendBlock("[copy]", `copied ${summary} to clipboard via ${result.via}`, COLORS.system);
         }
         else {
@@ -1569,6 +1708,37 @@ export async function runTui(input) {
                 (process.platform === "linux" ? "\nInstall one of: wl-clipboard, xclip, xsel" : ""), COLORS.error);
         }
     }
+    /**
+     * Two-stage clipboard write. The platform-native CLI (pbcopy / wl-copy /
+     * xclip / xsel / clip.exe) goes first because it actually writes to the
+     * OS clipboard and — critically — `writeClipboardText` reads the
+     * clipboard back through pbpaste / wl-paste / xclip -o to confirm the
+     * bytes landed. Exit-code-only success is not enough: pbcopy from inside
+     * a raw-mode TUI on Warp/macOS exits 0 without actually updating
+     * NSPasteboard, and OSC 52 has the same silent-drop problem on Warp.
+     *
+     * OSC 52 is only the fallback when no local CLI is available at all
+     * (e.g. an SSH session with no clipboard tool installed remotely). When
+     * a local CLI ran but failed verification we surface that error
+     * directly instead of falling through to OSC 52, because OSC 52 would
+     * also silently "succeed" on the same broken terminals and hide the
+     * real failure behind a fake "copied via OSC 52" line.
+     */
+    async function copyTextToClipboard(text) {
+        const cli = await writeClipboardText(text);
+        if (cli.ok)
+            return cli;
+        // Only fall back to OSC 52 when the CLI was simply unavailable. If a
+        // CLI ran but the readback did not match (cli.kind ===
+        // "verification-failed"), OSC 52 is on the same broken pipe and
+        // would silently "succeed" the same way — surface the real error.
+        if (cli.kind === "no-writer" &&
+            renderer.isOsc52Supported() &&
+            renderer.copyToClipboardOSC52(text)) {
+            return { ok: true, via: "OSC 52" };
+        }
+        return cli;
+    }
     function describeCopySelection(argument, length) {
         const chars = `${length} char${length === 1 ? "" : "s"}`;
         if (argument === "last")
@@ -1595,7 +1765,7 @@ export async function runTui(input) {
             // can keep typing their prompt with the image already attached.
             inputField.insertText(pending.label);
             appendBlock("[paste]", `attached ${pending.label} from ${pending.path}`, COLORS.system);
-            refreshAttachmentHint();
+            refreshHint();
         }
         catch (error) {
             appendBlock("[paste]", error instanceof Error ? error.message : String(error), COLORS.error);