@agent-api/cli 0.4.21 → 0.4.22

package/dist/runtime.d.ts

@@ -1,4 +1,4 @@
 export declare const cliName = "agent-tui";
 export declare const cliAuthor = "AgentsWay";
-export declare const cliVersion = "0.4.21";
+export declare const cliVersion = "0.4.22";
 export declare const legacyCliName = "agent-api-cli";

package/dist/runtime.js

@@ -1,4 +1,4 @@
 export const cliName = "agent-tui";
 export const cliAuthor = "AgentsWay";
-export const cliVersion = "0.4.21";
+export const cliVersion = "0.4.22";
 export const legacyCliName = "agent-api-cli";

package/dist/tui/clipboard.d.ts

@@ -0,0 +1 @@
+export declare function writeClipboard(text: string, stdout?: NodeJS.WriteStream): Promise<boolean>;

package/dist/tui/clipboard.js

@@ -0,0 +1,48 @@
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+export async function writeClipboard(text, stdout = process.stdout) {
+    const osc52Written = writeOsc52(text, stdout);
+    const nativeWritten = await writeNativeClipboard(text);
+    return osc52Written || nativeWritten;
+}
+function writeOsc52(text, stdout) {
+    if (!stdout.isTTY)
+        return false;
+    const sequence = `\x1b]52;c;${Buffer.from(text).toString("base64")}\x07`;
+    stdout.write(process.env.TMUX || process.env.STY ? `\x1bPtmux;\x1b${sequence}\x1b\\` : sequence);
+    return true;
+}
+async function writeNativeClipboard(text) {
+    const commands = nativeClipboardCommands();
+    for (const [command, args] of commands) {
+        if (await writeCommand(command, args, text))
+            return true;
+    }
+    return false;
+}
+function nativeClipboardCommands() {
+    if (platform() === "darwin")
+        return [["pbcopy", []]];
+    if (platform() === "win32") {
+        return [["powershell.exe", [
+                    "-NonInteractive",
+                    "-NoProfile",
+                    "-Command",
+                    "[Console]::InputEncoding = [System.Text.Encoding]::UTF8; Set-Clipboard -Value ([Console]::In.ReadToEnd())",
+                ]]];
+    }
+    const commands = [];
+    if (process.env.WAYLAND_DISPLAY)
+        commands.push(["wl-copy", []]);
+    commands.push(["xclip", ["-selection", "clipboard"]]);
+    commands.push(["xsel", ["--clipboard", "--input"]]);
+    return commands;
+}
+function writeCommand(command, args, input) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, { stdio: ["pipe", "ignore", "ignore"] });
+        child.on("error", () => resolve(false));
+        child.on("close", (code) => resolve(code === 0));
+        child.stdin.end(input);
+    });
+}

package/dist/tui/ink/app.js

@@ -2,9 +2,11 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { useApp, useInput, useStdout } from "ink";
 import { createAgentEngine, defaultBaseURL, } from "@agent-api/app-engine/core";
-import { createWorkbenchAuthController, createWorkbenchAuthGateController, } from "@agent-api/app-engine/workbench";
-import { buildWorkbenchRenderModel, createWorkbenchInputController, } from "@agent-api/app-engine/terminal";
+import { createWorkbenchAuthController, createWorkbenchAuthGateController, parseWorkbenchCommand, } from "@agent-api/app-engine/workbench";
+import { buildWorkbenchRenderModel, copyTextFromActivitySelection, copyTextFromRenderModel, copyTextFromTranscriptSelection, createWorkbenchTerminalController, initialWorkbenchTerminalState, normalizeTerminalState, selectedPanelRange, } from "@agent-api/app-engine/terminal";
 import { InkAuthGate, InkWorkbenchScreen } from "./components.js";
+import { writeClipboard } from "../clipboard.js";
+import { disableMouseReporting, enableMouseReporting, parseMouseEvent } from "../mouse.js";
 export function ChatApp({ options }) {
     return _jsx(AuthenticatedChatApp, { options: options });
 }
@@ -31,7 +33,11 @@ function AuthenticatedChatApp({ options }) {
     }));
     useEffect(() => {
         hideTerminalCursor(stdout);
-        return () => showTerminalCursor(stdout);
+        enableTerminalMouse(stdout);
+        return () => {
+            disableTerminalMouse(stdout);
+            showTerminalCursor(stdout);
+        };
     }, [stdout]);
     useEffect(() => {
         let mounted = true;
@@ -58,6 +64,8 @@ function AuthenticatedChatApp({ options }) {
         return () => clearInterval(interval);
     }, [auth.status]);
     useInput((input, key) => {
+        if (parseMouseEvent(input))
+            return;
         const result = authGateController.handleInput(input, key, auth);
         if (result.state !== auth)
             setAuth(result.state);
@@ -110,6 +118,14 @@ function showTerminalCursor(stdout) {
     if (stdout.isTTY)
         stdout.write("\x1b[?25h");
 }
+function enableTerminalMouse(stdout) {
+    if (stdout.isTTY)
+        stdout.write(enableMouseReporting);
+}
+function disableTerminalMouse(stdout) {
+    if (stdout.isTTY)
+        stdout.write(disableMouseReporting);
+}
 function isAuthInputStatus(status) {
     return status === "api_profile"
         || status === "api_base_url"
@@ -121,11 +137,8 @@ function WorkbenchApp({ authController, onLogin, onLogout, onDeleteProfile, onSw
     const app = useApp();
     const { stdout } = useStdout();
     const terminalSize = useTerminalSize(stdout);
-    const [draft, setDraft] = useState("");
-    const [cursor, setCursor] = useState(0);
-    const [selectionAnchor, setSelectionAnchor] = useState(null);
+    const [terminalState, setTerminalState] = useState(() => initialWorkbenchTerminalState());
     const [spinnerFrame, setSpinnerFrame] = useState(0);
-    const [transcriptOffset, setTranscriptOffset] = useState(0);
     const agentEngineRef = useRef(null);
     if (!agentEngineRef.current) {
         agentEngineRef.current = createAgentEngine({
@@ -140,38 +153,71 @@ function WorkbenchApp({ authController, onLogin, onLogout, onDeleteProfile, onSw
         });
     }
     const agentEngine = agentEngineRef.current;
-    const inputControllerRef = useRef(null);
-    if (!inputControllerRef.current) {
-        inputControllerRef.current = createWorkbenchInputController();
+    const terminalControllerRef = useRef(null);
+    if (!terminalControllerRef.current) {
+        terminalControllerRef.current = createWorkbenchTerminalController();
     }
-    const inputController = inputControllerRef.current;
+    const terminalController = terminalControllerRef.current;
     const state = useSyncExternalStore(agentEngine.subscribe, agentEngine.snapshot, agentEngine.snapshot);
     const dispatch = agentEngine.dispatch;
     const renderModel = useMemo(() => buildWorkbenchRenderModel({
-        draft,
-        cursor,
+        draft: terminalState.draft,
+        cursor: terminalState.cursor,
         profileName,
-        selectionAnchor,
+        selectionAnchor: terminalState.selectionAnchor,
         spinnerFrame,
         state,
-        transcriptOffset,
+        transcriptOffset: terminalState.transcriptOffset,
         viewport: {
             rows: terminalSize.rows,
             columns: terminalSize.columns,
         },
         workdirFallback: options.workdir || process.cwd(),
-    }), [cursor, draft, options.workdir, profileName, selectionAnchor, spinnerFrame, state, terminalSize.columns, terminalSize.rows, transcriptOffset]);
+    }), [options.workdir, profileName, spinnerFrame, state, terminalSize.columns, terminalSize.rows, terminalState.cursor, terminalState.draft, terminalState.selectionAnchor, terminalState.transcriptOffset]);
     useEffect(() => {
-        setTranscriptOffset((offset) => Math.min(offset, renderModel.transcript.maxOffset));
-    }, [renderModel.transcript.maxOffset]);
-    function scrollTranscript(delta) {
-        setTranscriptOffset((offset) => Math.max(0, Math.min(renderModel.transcript.maxOffset, offset + delta)));
+        setTerminalState((current) => {
+            const next = normalizeTerminalState(current, renderModel);
+            return sameTerminalState(current, next) ? current : next;
+        });
+    }, [renderModel]);
+    async function submitInput(input) {
+        const command = parseWorkbenchCommand(input);
+        if (command?.kind === "copy") {
+            await copyPanelText(command.target);
+            return;
+        }
+        await agentEngine.submit(input);
     }
-    function scrollTranscriptToTop() {
-        setTranscriptOffset(renderModel.transcript.maxOffset);
+    async function copyPanelText(target) {
+        const text = copyTextForTarget(target);
+        if (!text) {
+            dispatch({ type: "activity.add", level: "warning", text: `Nothing to copy: ${target}` });
+            return;
+        }
+        try {
+            const copied = await writeClipboard(text, stdout);
+            dispatch({
+                type: "activity.add",
+                level: copied ? "success" : "warning",
+                text: copied ? `Copied ${target} to clipboard` : `Clipboard unavailable for ${target}`,
+            });
+        }
+        catch (error) {
+            dispatch({ type: "activity.add", level: "error", text: `Copy failed: ${userFacingError(error)}` });
+        }
     }
-    function scrollTranscriptToBottom() {
-        setTranscriptOffset(0);
+    function copyTextForTarget(target) {
+        if (target === "transcript" || target === "page") {
+            const selection = selectedPanelRange(terminalState.transcriptSelectionAnchor, terminalState.transcriptCursor);
+            if (selection)
+                return copyTextFromTranscriptSelection(renderModel.transcript.lines, selection);
+        }
+        if (target === "activity") {
+            const selection = selectedPanelRange(terminalState.activitySelectionAnchor, terminalState.activityCursor);
+            if (selection)
+                return copyTextFromActivitySelection(renderModel.visibleActivities, selection);
+        }
+        return copyTextFromRenderModel(renderModel, target);
     }
     useEffect(() => {
         let mounted = true;
@@ -206,44 +252,55 @@ function WorkbenchApp({ authController, onLogin, onLogout, onDeleteProfile, onSw
         };
     }, [agentEngine, options.profile]);
     useInput((input, key) => {
-        const result = inputController.handle(input, key, {
+        const mouse = parseMouseEvent(input);
+        if (mouse) {
+            const result = terminalController.handleMouse(mouse, terminalState, {
+                busy: state.busy,
+                renderModel,
+            });
+            if (!sameTerminalState(result.state, terminalState))
+                setTerminalState(result.state);
+            return;
+        }
+        const result = terminalController.handle(input, key, terminalState, {
             busy: state.busy,
-            cursor,
-            draft,
-            selectionAnchor,
-            viewportColumns: renderModel.input.viewportColumns,
-            viewportHeight: renderModel.viewportHeight,
+            renderModel,
         });
-        if (result.draft !== draft)
-            setDraft(result.draft);
-        if (result.cursor !== cursor)
-            setCursor(result.cursor);
-        if (result.selectionAnchor !== selectionAnchor)
-            setSelectionAnchor(result.selectionAnchor);
+        if (!sameTerminalState(result.state, terminalState))
+            setTerminalState(result.state);
         for (const effect of result.effects) {
             switch (effect.type) {
                 case "exit":
                     app.exit();
                     break;
                 case "scroll":
-                    scrollTranscript(effect.delta);
+                    setTerminalState((current) => normalizeTerminalState({
+                        ...current,
+                        transcriptOffset: current.transcriptOffset + effect.delta,
+                    }, renderModel));
                     break;
                 case "scroll_top":
-                    scrollTranscriptToTop();
+                    setTerminalState((current) => normalizeTerminalState({
+                        ...current,
+                        transcriptOffset: renderModel.transcript.maxOffset,
+                    }, renderModel));
                     break;
                 case "scroll_bottom":
-                    scrollTranscriptToBottom();
+                    setTerminalState((current) => ({ ...current, transcriptOffset: 0 }));
                     break;
                 case "abort":
                     void agentEngine.abortActiveTurn("Abort requested.");
                     break;
                 case "submit":
-                    void agentEngine.submit(effect.input);
+                    void submitInput(effect.input);
                     break;
                 case "ignored_busy":
                     dispatch({ type: "message.add", role: "system", text: "Agent turn is running. Use /abort or Esc to cancel it." });
                     dispatch({ type: "activity.add", level: "warning", text: "Input ignored while agent is running" });
                     break;
+                case "copy":
+                    void copyPanelText(effect.target);
+                    break;
             }
         }
     });
@@ -263,7 +320,7 @@ function WorkbenchApp({ authController, onLogin, onLogout, onDeleteProfile, onSw
     useEffect(() => {
         return () => agentEngine.dispose();
     }, [agentEngine]);
-    return _jsx(InkWorkbenchScreen, { renderModel: renderModel, spinnerFrame: spinnerFrame });
+    return (_jsx(InkWorkbenchScreen, { activityCursor: terminalState.activityCursor, activitySelection: selectedPanelRange(terminalState.activitySelectionAnchor, terminalState.activityCursor), focusedPanel: terminalState.focusedPanel, renderModel: renderModel, spinnerFrame: spinnerFrame, transcriptCursor: terminalState.transcriptCursor, transcriptSelection: selectedPanelRange(terminalState.transcriptSelectionAnchor, terminalState.transcriptCursor) }));
 }
 function useTerminalSize(stdout) {
     const [size, setSize] = useState(() => ({
@@ -292,3 +349,27 @@ function useTerminalSize(stdout) {
     }, [stdout]);
     return size;
 }
+function userFacingError(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+function sameTerminalState(a, b) {
+    return a.activityCursor.line === b.activityCursor.line
+        && a.activityCursor.column === b.activityCursor.column
+        && samePositionOrNull(a.activitySelectionAnchor, b.activitySelectionAnchor)
+        && a.cursor === b.cursor
+        && a.draft === b.draft
+        && a.focusedPanel === b.focusedPanel
+        && a.mouseDragPanel === b.mouseDragPanel
+        && a.selectionAnchor === b.selectionAnchor
+        && a.transcriptCursor.line === b.transcriptCursor.line
+        && a.transcriptCursor.column === b.transcriptCursor.column
+        && a.transcriptOffset === b.transcriptOffset
+        && samePositionOrNull(a.transcriptSelectionAnchor, b.transcriptSelectionAnchor);
+}
+function samePositionOrNull(a, b) {
+    if (a === null || b === null)
+        return a === b;
+    return a.line === b.line && a.column === b.column;
+}

package/dist/tui/ink/components.d.ts

@@ -1,9 +1,14 @@
 import React from "react";
-import { type WorkbenchRenderModel } from "@agent-api/app-engine/terminal";
+import { type WorkbenchPanelPosition, type WorkbenchPanelSelection, type WorkbenchRenderModel } from "@agent-api/app-engine/terminal";
 import { type AuthGateState } from "@agent-api/app-engine/workbench";
-export declare function InkWorkbenchScreen({ renderModel, spinnerFrame, }: {
+export declare function InkWorkbenchScreen({ activityCursor, activitySelection, focusedPanel, renderModel, spinnerFrame, transcriptCursor, transcriptSelection, }: {
+    activityCursor: WorkbenchPanelPosition;
+    activitySelection: WorkbenchPanelSelection | null;
+    focusedPanel: "activity" | "input" | "transcript";
     renderModel: WorkbenchRenderModel;
     spinnerFrame: number;
+    transcriptCursor: WorkbenchPanelPosition;
+    transcriptSelection: WorkbenchPanelSelection | null;
 }): React.JSX.Element;
 export declare function InkAuthGate({ cursorVisible, state }: {
     cursorVisible: boolean;

package/dist/tui/ink/components.js

@@ -1,16 +1,85 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { activityColor, busySpinner, } from "@agent-api/app-engine/terminal";
 import { authMethods, } from "@agent-api/app-engine/workbench";
-export function InkWorkbenchScreen({ renderModel, spinnerFrame, }) {
-    const activity = (_jsxs(Box, { flexDirection: "column", width: renderModel.layout === "wide" ? "28%" : "100%", height: renderModel.activityHeight, borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { bold: true, wrap: "truncate", children: "Activity" }), renderModel.visibleActivities.map((activity) => (_jsxs(Text, { color: activityColor(activity.level), wrap: "truncate", children: [new Date(activity.timestamp).toLocaleTimeString(), " ", activity.text] }, activity.id)))] }));
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { contextEnabled: renderModel.header.contextEnabled, conversation: renderModel.header.conversation, conversationId: renderModel.header.conversationId, conversationPreviousResponseId: renderModel.header.conversationPreviousResponseId, conversationStatus: renderModel.header.conversationStatus, model: renderModel.header.model, accessMode: renderModel.header.accessMode, pendingLocalLabel: renderModel.header.pendingLocalLabel, preset: renderModel.header.preset, profile: renderModel.header.profile, renderMode: renderModel.header.renderMode, workdir: renderModel.header.workdir }), _jsxs(Box, { height: renderModel.viewportHeight, flexDirection: renderModel.layout === "wide" ? "row" : "column", children: [_jsxs(Box, { flexDirection: "column", width: renderModel.layout === "wide" ? "72%" : "100%", paddingRight: renderModel.layout === "wide" ? 1 : 0, children: [renderModel.transcript.visibleLines.map((line) => (_jsx(TranscriptText, { line: line }, line.id))), renderModel.transcript.visibleLines.length === 0 && _jsx(Text, { color: "gray", children: "No transcript lines." })] }), activity] }), _jsxs(Box, { borderStyle: "single", borderColor: renderModel.input.busy ? "yellow" : "green", paddingX: 1, flexDirection: "column", children: [_jsxs(Box, { children: [renderModel.input.fullAccess && (_jsx(Text, { color: "red", bold: true, inverse: true, children: "FULL ACCESS" })), renderModel.input.fullAccess && _jsx(Text, { children: " " }), _jsx(Text, { color: renderModel.input.busy ? "yellow" : "green", children: renderModel.input.label }), renderModel.input.statusText && (_jsxs(Text, { color: "yellow", children: ["  ", busySpinner(spinnerFrame), " ", renderModel.input.statusText] }))] }), _jsx(Box, { flexDirection: "column", children: renderModel.input.lines.map((line, index) => (_jsx(Text, { wrap: "truncate", children: line.spans.map((span, spanIndex) => (_jsx(Text, { inverse: span.inverse, children: span.text }, spanIndex))) }, index))) })] }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { color: "gray", wrap: "truncate", children: renderModel.footerText }) })] }));
+export function InkWorkbenchScreen({ activityCursor, activitySelection, focusedPanel, renderModel, spinnerFrame, transcriptCursor, transcriptSelection, }) {
+    const activity = (_jsxs(Box, { flexDirection: "column", width: renderModel.layout === "wide" ? "28%" : "100%", height: renderModel.activityHeight, borderStyle: "single", borderColor: focusedPanel === "activity" ? "cyan" : "gray", paddingX: 1, children: [_jsx(Text, { bold: true, wrap: "truncate", children: "Activity" }), renderModel.visibleActivities.map((activity, index) => {
+                const cursor = focusedPanel === "activity" && index === activityCursor.line;
+                const text = `${new Date(activity.timestamp).toLocaleTimeString()} ${activity.text}`;
+                return (_jsxs(Text, { color: activityColor(activity.level), wrap: "truncate", children: [cursor ? _jsx(Text, { color: "cyan", children: "\u203A " }) : _jsx(Text, { children: "  " }), _jsx(SelectableText, { cursorColumn: cursor && !activitySelection ? activityCursor.column : null, selection: lineSelection(index, activitySelection), text: text || " " })] }, activity.id));
+            })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { contextEnabled: renderModel.header.contextEnabled, conversation: renderModel.header.conversation, conversationId: renderModel.header.conversationId, conversationPreviousResponseId: renderModel.header.conversationPreviousResponseId, conversationStatus: renderModel.header.conversationStatus, model: renderModel.header.model, accessMode: renderModel.header.accessMode, pendingLocalLabel: renderModel.header.pendingLocalLabel, preset: renderModel.header.preset, profile: renderModel.header.profile, renderMode: renderModel.header.renderMode, workdir: renderModel.header.workdir }), _jsxs(Box, { height: renderModel.viewportHeight, flexDirection: renderModel.layout === "wide" ? "row" : "column", children: [_jsxs(Box, { flexDirection: "column", width: renderModel.layout === "wide" ? "72%" : "100%", paddingRight: renderModel.layout === "wide" ? 1 : 0, children: [renderModel.transcript.visibleLines.map((line, index) => (_jsx(TranscriptText, { cursorColumn: focusedPanel === "transcript" && renderModel.transcript.startLine + index - 1 === transcriptCursor.line && !transcriptSelection
+                                    ? transcriptCursor.column
+                                    : null, line: line, lineSelection: lineSelection(renderModel.transcript.startLine + index - 1, transcriptSelection), lineCursor: focusedPanel === "transcript" && renderModel.transcript.startLine + index - 1 === transcriptCursor.line }, line.id))), renderModel.transcript.visibleLines.length === 0 && _jsx(Text, { color: "gray", children: "No transcript lines." })] }), activity] }), _jsxs(Box, { borderStyle: "single", borderColor: focusedPanel === "input" ? renderModel.input.busy ? "yellow" : "green" : "gray", paddingX: 1, flexDirection: "column", children: [_jsxs(Box, { children: [renderModel.input.fullAccess && (_jsx(Text, { color: "red", bold: true, inverse: true, children: "FULL ACCESS" })), renderModel.input.fullAccess && _jsx(Text, { children: " " }), _jsx(Text, { color: renderModel.input.busy ? "yellow" : "green", children: renderModel.input.label }), renderModel.input.statusText && (_jsxs(Text, { color: "yellow", children: ["  ", busySpinner(spinnerFrame), " ", renderModel.input.statusText] }))] }), _jsx(Box, { flexDirection: "column", children: renderModel.input.lines.map((line, index) => (_jsx(Text, { wrap: "truncate", children: line.spans.map((span, spanIndex) => (_jsx(Text, { inverse: span.inverse, children: span.text }, spanIndex))) }, index))) })] }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { color: "gray", wrap: "truncate", children: renderModel.footerText }) })] }));
 }
-function TranscriptText({ line }) {
+function TranscriptText({ cursorColumn, line, lineCursor, lineSelection, }) {
+    const anchor = lineCursor ? _jsx(Text, { color: "cyan", children: "\u203A " }) : line.anchor ? _jsx(Text, { color: "cyan", children: "\u25B8 " }) : _jsx(Text, { children: "  " });
     if (!line.spans || line.spans.length === 0) {
-        return (_jsx(Text, { bold: line.bold, color: line.color, inverse: line.inverse, wrap: "truncate", children: line.text || " " }));
+        return (_jsxs(Text, { bold: line.bold || lineCursor, color: line.color, inverse: line.inverse, wrap: "truncate", children: [anchor, _jsx(SelectableText, { cursorColumn: cursorColumn, selection: lineSelection, text: line.text || " " })] }));
     }
-    return (_jsx(Text, { bold: line.bold, color: line.color, inverse: line.inverse, wrap: "truncate", children: line.spans.map((span, index) => (_jsx(Text, { bold: span.bold, color: span.color, inverse: span.inverse, children: span.text }, index))) }));
+    return (_jsxs(Text, { bold: line.bold || lineCursor, color: line.color, inverse: line.inverse, wrap: "truncate", children: [anchor, line.spans.map((span, index) => {
+                const offset = line.spans?.slice(0, index).reduce((sum, item) => sum + item.text.length, 0) ?? 0;
+                return (_jsx(SelectableText, { bold: span.bold, color: span.color, cursorColumn: cursorColumn, lineLength: line.text.length, offset: offset, selection: lineSelection, text: span.text }, index));
+            })] }));
+}
+function SelectableText({ bold, color, cursorColumn, lineLength, offset = 0, selection, text, }) {
+    const pieces = selectablePieces(text, { cursorColumn, lineLength: lineLength ?? text.length, offset, selection });
+    return (_jsx(_Fragment, { children: pieces.map((piece, index) => (_jsx(Text, { bold: bold, color: color, inverse: piece.inverse, children: piece.text }, index))) }));
+}
+function lineSelection(line, selection) {
+    if (!selection || line < selection.start.line || line > selection.end.line)
+        return null;
+    if (selection.start.line === selection.end.line) {
+        return selection.start.column === selection.end.column
+            ? null
+            : { start: selection.start.column, end: selection.end.column };
+    }
+    if (line === selection.start.line)
+        return { start: selection.start.column, end: Number.POSITIVE_INFINITY };
+    if (line === selection.end.line)
+        return { start: 0, end: selection.end.column };
+    return { start: 0, end: Number.POSITIVE_INFINITY };
+}
+function selectablePieces(text, options) {
+    const textLength = text.length;
+    const selection = options.selection
+        ? {
+            start: clamp(options.selection.start - options.offset, 0, textLength),
+            end: clamp(options.selection.end - options.offset, 0, textLength),
+        }
+        : null;
+    const segmentEnd = options.offset + textLength;
+    const cursorInSegment = options.cursorColumn != null
+        && options.cursorColumn >= options.offset
+        && (options.cursorColumn < segmentEnd
+            || (options.cursorColumn === options.lineLength && segmentEnd === options.lineLength));
+    const cursor = cursorInSegment ? clamp((options.cursorColumn ?? 0) - options.offset, 0, textLength) : null;
+    const boundaries = new Set([0, textLength]);
+    if (selection && selection.start !== selection.end) {
+        boundaries.add(selection.start);
+        boundaries.add(selection.end);
+    }
+    if (cursor !== null) {
+        boundaries.add(cursor);
+        boundaries.add(Math.min(textLength, cursor + 1));
+    }
+    const sorted = Array.from(boundaries).sort((a, b) => a - b);
+    const pieces = [];
+    for (let index = 0; index < sorted.length - 1; index += 1) {
+        const start = sorted[index] ?? 0;
+        const end = sorted[index + 1] ?? start;
+        if (end <= start)
+            continue;
+        const selected = Boolean(selection && start >= selection.start && end <= selection.end);
+        const cursorAtPiece = cursor !== null && start >= cursor && start < cursor + 1;
+        pieces.push({ text: text.slice(start, end), inverse: selected || cursorAtPiece });
+    }
+    if (cursor === textLength)
+        pieces.push({ text: " ", inverse: true });
+    return pieces.length ? pieces : [{ text }];
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(value, max));
 }
 export function InkAuthGate({ cursorVisible, state }) {
     return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Agent API Workbench" }), _jsx(Text, { color: "gray", children: "Authentication required before starting the conversation UI." })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: state.error ? "red" : "gray", children: state.error || state.message }), state.status === "checking" && _jsx(Text, { color: "yellow", children: "Checking..." }), state.status === "select" && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [authMethods.map((method, index) => (_jsxs(Text, { color: index === state.selectedMethod ? "green" : "gray", children: [index === state.selectedMethod ? "›" : " ", " ", method.label, " - ", method.description] }, method.method))), _jsx(Text, { color: "gray", children: "Use \u2191/\u2193 and Enter." })] })), state.status === "api_profile" && _jsx(AuthPrompt, { cursorVisible: cursorVisible, label: "Profile", value: state.profile }), state.status === "api_base_url" && _jsx(AuthPrompt, { cursorVisible: cursorVisible, label: "Base URL", value: state.baseURL }), state.status === "api_key" && _jsx(AuthPrompt, { cursorVisible: cursorVisible, label: "API key", value: state.apiKey ? "•".repeat(Math.min(state.apiKey.length, 32)) : "" }), state.status === "browser_profile" && _jsx(AuthPrompt, { cursorVisible: cursorVisible, label: "Profile", value: state.profile }), state.status === "browser_base_url" && _jsx(AuthPrompt, { cursorVisible: cursorVisible, label: "Base URL", value: state.baseURL }), state.status === "browser_waiting" && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [state.browserURL && _jsxs(Text, { children: ["URL: ", state.browserURL] }), state.browserCode && _jsxs(Text, { children: ["Code: ", state.browserCode] }), _jsx(Text, { color: "yellow", children: "Waiting for browser approval..." })] }))] })] }));

package/dist/tui/mouse.d.ts

@@ -0,0 +1,4 @@
+import type { WorkbenchTerminalMouseEvent } from "@agent-api/app-engine/terminal";
+export declare const enableMouseReporting = "\u001B[?1000h\u001B[?1002h\u001B[?1006h";
+export declare const disableMouseReporting = "\u001B[?1000l\u001B[?1002l\u001B[?1006l";
+export declare function parseMouseEvent(input: string): WorkbenchTerminalMouseEvent | null;

package/dist/tui/mouse.js

@@ -0,0 +1,30 @@
+export const enableMouseReporting = "\x1b[?1000h\x1b[?1002h\x1b[?1006h";
+export const disableMouseReporting = "\x1b[?1000l\x1b[?1002l\x1b[?1006l";
+export function parseMouseEvent(input) {
+    const match = /\x1b\[<(\d+);(\d+);(\d+)([mM])/.exec(input);
+    if (!match)
+        return null;
+    const code = Number(match[1]);
+    const column = Number(match[2]);
+    const row = Number(match[3]);
+    if (!Number.isFinite(code) || !Number.isFinite(column) || !Number.isFinite(row))
+        return null;
+    if (code === 64)
+        return { button: "wheel_up", column, kind: "wheel", row };
+    if (code === 65)
+        return { button: "wheel_down", column, kind: "wheel", row };
+    if ((code & 32) === 32) {
+        return {
+            button: (code & 3) === 0 ? "left" : "unknown",
+            column,
+            kind: "motion",
+            row,
+        };
+    }
+    return {
+        button: (code & 3) === 0 ? "left" : "unknown",
+        column,
+        kind: match[4] === "m" ? "release" : "press",
+        row,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-api/cli",
-  "version": "0.4.21",
+  "version": "0.4.22",
   "description": "First-class command line interface for Agent API",
   "license": "MIT",
   "homepage": "https://github.com/scalebox-dev/agent-tui#readme",
@@ -35,7 +35,7 @@
     "test": "npm run sync-version && npm run build && npm run smoke -w @agent-api/app-engine && node --test test/*.test.mjs"
   },
   "dependencies": {
-    "@agent-api/app-engine": "^0.1.20",
+    "@agent-api/app-engine": "^0.1.21",
     "commander": "^14.0.3",
     "ink": "^6.8.0",
     "react": "^19.2.7"