@duetso/agent 0.1.56 → 0.1.58

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,16 @@ 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();
+        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 +87,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 +120,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 +138,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 +166,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 +174,7 @@ export async function runTui(input) {
             fg: COLORS.hint,
             height: 1,
             flexShrink: 0,
+            selectable: false,
         });
         row.visible = false;
         return row;
@@ -169,11 +197,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 +211,7 @@ export async function runTui(input) {
             fg: COLORS.hint,
             wrapMode: "word",
             flexShrink: 0,
+            selectable: false,
         });
         row.visible = false;
         return row;
@@ -198,10 +229,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 +287,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 +315,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 +893,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);
     }
@@ -1149,7 +1169,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
@@ -1232,13 +1252,29 @@ 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) {
+        // Copy keystrokes. The set is intentionally generous because each
+        // mainstream terminal forwards a different subset:
+        //
+        //   - Cmd+C: macOS muscle memory; many terminals (Terminal.app, Warp)
+        //     own this for their own selection UI and never forward it.
+        //   - Cmd+Shift+C: forwarded by Warp on macOS and by some configs of
+        //     iTerm2 / Ghostty where Cmd+C is reserved.
+        //   - Ctrl+Shift+C: Linux/Windows terminal-app convention that
+        //     leaves bare Ctrl+C free for "exit."
+        //
+        // The hint label surfaces only the OS-natural one so the bottom row
+        // stays terse. No-op when nothing is selected so the keystroke still
+        // falls through to whatever the terminal would do natively. We accept
+        // both "c" and "C" because some kitty parsers report the shifted
+        // letter while others report the base letter plus shift=true.
+        const isCopyLetter = key.name === "c" || key.name === "C";
+        const cmdHeld = key.super || key.meta;
+        const isCmdC = isCopyLetter && cmdHeld && !key.shift && !key.ctrl;
+        const isCmdShiftC = isCopyLetter && cmdHeld && key.shift && !key.ctrl;
+        const isCtrlShiftC = isCopyLetter && key.ctrl && key.shift && !cmdHeld;
+        if ((isCmdC || isCmdShiftC || isCtrlShiftC) && lastSelectionText.trim().length > 0) {
             key.preventDefault();
-            void handleCopySlashCommand("/copy");
+            void copyActiveSelection();
             return;
         }
         if (skillAutocompleteIsOpen()) {
@@ -1335,10 +1371,20 @@ 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);
+    }
     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 +1451,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 +1491,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 +1502,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
@@ -1541,27 +1587,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 +1651,19 @@ export async function runTui(input) {
                 (process.platform === "linux" ? "\nInstall one of: wl-clipboard, xclip, xsel" : ""), COLORS.error);
         }
     }
+    /**
+     * Two-stage clipboard write. OpenTUI's OSC 52 path is preferred because it
+     * lands in the user's clipboard even when the TUI is running over SSH or
+     * inside tmux — no host CLI required. When the terminal does not
+     * advertise OSC 52 support (or stdout is gone), fall back to the
+     * platform-native CLI writers in `clipboard.ts`.
+     */
+    async function copyTextToClipboard(text) {
+        if (renderer.isOsc52Supported() && renderer.copyToClipboardOSC52(text)) {
+            return { ok: true, via: "OSC 52" };
+        }
+        return writeClipboardText(text);
+    }
     function describeCopySelection(argument, length) {
         const chars = `${length} char${length === 1 ? "" : "s"}`;
         if (argument === "last")
@@ -1595,7 +1690,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);