@otto-code/protocol 0.5.0

package/dist/terminal-input-mode.js

@@ -0,0 +1,151 @@
+export const DEFAULT_TERMINAL_INPUT_MODE_STATE = {
+    kittyKeyboardFlags: 0,
+    win32InputMode: false,
+};
+const ESC = String.fromCharCode(0x1b);
+const WIN32_INPUT_MODE = 9001;
+const CSI_INPUT_MODE_SEQUENCE = new RegExp(`${ESC}\\[(?:([<>=?]?)([0-9;]*)u|\\?([0-9;]*)([hl]))`, "g");
+const INCOMPLETE_CSI_INPUT_MODE_SEQUENCE = new RegExp(`${ESC}\\[[<>=?]?[0-9;]*$`);
+function parseFirstParam(params) {
+    const first = params.split(";")[0];
+    if (!first || !/^\d+$/.test(first)) {
+        return null;
+    }
+    return Number(first);
+}
+function parseSecondParam(params) {
+    const second = params.split(";")[1];
+    if (!second || !/^\d+$/.test(second)) {
+        return null;
+    }
+    return Number(second);
+}
+function parsePrivateModeParams(params) {
+    const modes = new Set();
+    for (const param of params.split(";")) {
+        if (/^\d+$/.test(param)) {
+            modes.add(Number(param));
+        }
+    }
+    return modes;
+}
+export function terminalInputModeSupportsModifiedEnter(state) {
+    return state.kittyKeyboardFlags > 0 || state.win32InputMode;
+}
+export function terminalInputModeStatesEqual(left, right) {
+    return (left.kittyKeyboardFlags === right.kittyKeyboardFlags &&
+        left.win32InputMode === right.win32InputMode);
+}
+export class TerminalInputModeTracker {
+    constructor() {
+        this.kittyKeyboardFlags = 0;
+        this.win32InputMode = false;
+        this.kittyKeyboardStack = [];
+        this.pending = "";
+    }
+    feed(data) {
+        if (data.length === 0) {
+            return { changed: false, responses: [] };
+        }
+        const text = `${this.pending}${data}`;
+        this.pending = "";
+        let changed = false;
+        const responses = [];
+        let consumedUntil = 0;
+        CSI_INPUT_MODE_SEQUENCE.lastIndex = 0;
+        for (;;) {
+            const match = CSI_INPUT_MODE_SEQUENCE.exec(text);
+            if (!match) {
+                break;
+            }
+            consumedUntil = CSI_INPUT_MODE_SEQUENCE.lastIndex;
+            if (match[4]) {
+                changed = this.applyPrivateModeSequence(match[3] ?? "", match[4]) || changed;
+                continue;
+            }
+            const result = this.applyKittyKeyboardSequence(match[1] ?? "", match[2] ?? "");
+            changed = changed || result.changed;
+            responses.push(...result.responses);
+        }
+        const tail = text.slice(consumedUntil);
+        const pendingStart = tail.lastIndexOf(`${ESC}[`);
+        if (pendingStart >= 0) {
+            const pending = tail.slice(pendingStart);
+            if (INCOMPLETE_CSI_INPUT_MODE_SEQUENCE.test(pending)) {
+                this.pending = pending;
+            }
+        }
+        return { changed, responses };
+    }
+    reset() {
+        this.kittyKeyboardFlags = 0;
+        this.win32InputMode = false;
+        this.kittyKeyboardStack.length = 0;
+        this.pending = "";
+    }
+    getState() {
+        return {
+            kittyKeyboardFlags: this.kittyKeyboardFlags,
+            win32InputMode: this.win32InputMode,
+        };
+    }
+    getKittyKeyboardFlags() {
+        return this.kittyKeyboardFlags;
+    }
+    supportsModifiedEnter() {
+        return terminalInputModeSupportsModifiedEnter(this.getState());
+    }
+    getPreamble() {
+        const parts = [];
+        if (this.kittyKeyboardFlags > 0) {
+            parts.push(`\x1b[=${this.kittyKeyboardFlags};1u`);
+        }
+        if (this.win32InputMode) {
+            parts.push("\x1b[?9001h");
+        }
+        return parts.join("");
+    }
+    applyKittyKeyboardSequence(prefix, params) {
+        const previousFlags = this.kittyKeyboardFlags;
+        switch (prefix) {
+            case ">": {
+                this.kittyKeyboardStack.push(this.kittyKeyboardFlags);
+                this.kittyKeyboardFlags = parseFirstParam(params) ?? 1;
+                break;
+            }
+            case "=": {
+                const mode = parseSecondParam(params) ?? 1;
+                this.kittyKeyboardFlags = mode === 0 ? 0 : (parseFirstParam(params) ?? 0);
+                break;
+            }
+            case "<": {
+                const count = Math.max(1, parseFirstParam(params) ?? 1);
+                for (let index = 0; index < count; index += 1) {
+                    this.kittyKeyboardFlags = this.kittyKeyboardStack.pop() ?? 0;
+                }
+                break;
+            }
+            case "?":
+                return {
+                    changed: false,
+                    responses: [`\x1b[?${this.kittyKeyboardFlags}u`],
+                };
+            default:
+                return { changed: false, responses: [] };
+        }
+        return {
+            changed: this.kittyKeyboardFlags !== previousFlags,
+            responses: [],
+        };
+    }
+    applyPrivateModeSequence(params, final) {
+        const modes = parsePrivateModeParams(params);
+        if (!modes.has(WIN32_INPUT_MODE)) {
+            return false;
+        }
+        const previous = this.win32InputMode;
+        this.win32InputMode = final === "h";
+        return this.win32InputMode !== previous;
+    }
+}
+//# sourceMappingURL=terminal-input-mode.js.map

package/dist/terminal-key-input.d.ts

@@ -0,0 +1,13 @@
+import type { TerminalInputModeState } from "./terminal-input-mode.js";
+export interface TerminalKeyInput {
+    key: string;
+    ctrl?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    meta?: boolean;
+}
+export interface TerminalKeyInputEncodingOptions {
+    inputMode?: TerminalInputModeState;
+}
+export declare function encodeTerminalKeyInput(input: TerminalKeyInput, options?: TerminalKeyInputEncodingOptions): string;
+//# sourceMappingURL=terminal-key-input.d.ts.map

package/dist/terminal-key-input.js

@@ -0,0 +1,201 @@
+const WIN32_LEFT_ALT_PRESSED = 0x0002;
+const WIN32_LEFT_CTRL_PRESSED = 0x0008;
+const WIN32_SHIFT_PRESSED = 0x0010;
+function modifierParam(input) {
+    let value = 1;
+    if (input.shift)
+        value += 1;
+    if (input.alt)
+        value += 2;
+    if (input.ctrl)
+        value += 4;
+    if (input.meta)
+        value += 8;
+    return value;
+}
+function win32ControlKeyState(input) {
+    let value = 0;
+    if (input.shift)
+        value += WIN32_SHIFT_PRESSED;
+    if (input.ctrl)
+        value += WIN32_LEFT_CTRL_PRESSED;
+    if (input.alt)
+        value += WIN32_LEFT_ALT_PRESSED;
+    return value;
+}
+function shouldUseWin32InputMode(input, options) {
+    if (!options.inputMode?.win32InputMode) {
+        return false;
+    }
+    return Boolean(input.shift || input.ctrl || input.alt);
+}
+function shouldUseKittyKeyboardMode(input, options) {
+    if ((options.inputMode?.kittyKeyboardFlags ?? 0) <= 0) {
+        return false;
+    }
+    return Boolean(input.shift || input.ctrl || input.alt || input.meta);
+}
+function encodeWin32EnterKeyInput(input) {
+    const controlKeyState = win32ControlKeyState(input);
+    // ConPTY Win32 input mode: CSI Vk;Sc;Uc;Kd;Cs;Rc _
+    return `\x1b[13;28;13;1;${controlKeyState};1_`;
+}
+function applyAltLikePrefix(sequence, input) {
+    return input.alt ? `\x1b${sequence}` : sequence;
+}
+function ctrlSymbolCode(char) {
+    switch (char) {
+        case " ":
+        case "@":
+        case "2":
+            return "\x00";
+        case "[":
+        case "3":
+            return "\x1b";
+        case "\\":
+        case "4":
+            return "\x1c";
+        case "]":
+        case "5":
+            return "\x1d";
+        case "^":
+        case "6":
+            return "\x1e";
+        case "_":
+        case "/":
+        case "7":
+            return "\x1f";
+        case "8":
+        case "?":
+            return "\x7f";
+        default:
+            return null;
+    }
+}
+function encodeCtrlChar(char, input) {
+    const upper = char.toUpperCase();
+    if (upper.length === 1 && upper >= "A" && upper <= "Z") {
+        return applyAltLikePrefix(String.fromCharCode(upper.charCodeAt(0) - 64), input);
+    }
+    const symbol = ctrlSymbolCode(char);
+    if (symbol !== null) {
+        return applyAltLikePrefix(symbol, input);
+    }
+    if (char.length === 1) {
+        const code = char.charCodeAt(0) & 0x1f;
+        return applyAltLikePrefix(String.fromCharCode(code), input);
+    }
+    return applyAltLikePrefix(char, input);
+}
+function encodePrintableKey(input) {
+    const raw = input.key;
+    const char = input.shift ? raw.toUpperCase() : raw;
+    if (input.ctrl) {
+        return encodeCtrlChar(char, input);
+    }
+    return applyAltLikePrefix(char, input);
+}
+function csiWithModifier(finalByte, input) {
+    const mod = modifierParam(input);
+    return mod === 1 ? `\x1b[${finalByte}` : `\x1b[1;${mod}${finalByte}`;
+}
+function csiTilde(base, input) {
+    const mod = modifierParam(input);
+    return mod === 1 ? `\x1b[${base}~` : `\x1b[${base};${mod}~`;
+}
+function encodeFunctionKey(key, input) {
+    switch (key) {
+        case "F1":
+            return modifierParam(input) === 1 ? "\x1bOP" : csiWithModifier("P", input);
+        case "F2":
+            return modifierParam(input) === 1 ? "\x1bOQ" : csiWithModifier("Q", input);
+        case "F3":
+            return modifierParam(input) === 1 ? "\x1bOR" : csiWithModifier("R", input);
+        case "F4":
+            return modifierParam(input) === 1 ? "\x1bOS" : csiWithModifier("S", input);
+        case "F5":
+            return csiTilde(15, input);
+        case "F6":
+            return csiTilde(17, input);
+        case "F7":
+            return csiTilde(18, input);
+        case "F8":
+            return csiTilde(19, input);
+        case "F9":
+            return csiTilde(20, input);
+        case "F10":
+            return csiTilde(21, input);
+        case "F11":
+            return csiTilde(23, input);
+        case "F12":
+            return csiTilde(24, input);
+        default:
+            return null;
+    }
+}
+function encodeNavigationKey(key, input) {
+    switch (key) {
+        case "ArrowUp":
+            return csiWithModifier("A", input);
+        case "ArrowDown":
+            return csiWithModifier("B", input);
+        case "ArrowRight":
+            return csiWithModifier("C", input);
+        case "ArrowLeft":
+            return csiWithModifier("D", input);
+        case "Home":
+            return csiWithModifier("H", input);
+        case "End":
+            return csiWithModifier("F", input);
+        case "Insert":
+            return csiTilde(2, input);
+        case "Delete":
+            return csiTilde(3, input);
+        case "PageUp":
+            return csiTilde(5, input);
+        case "PageDown":
+            return csiTilde(6, input);
+        default:
+            return null;
+    }
+}
+export function encodeTerminalKeyInput(input, options = {}) {
+    const key = input.key;
+    if (!key) {
+        return "";
+    }
+    if (key.length === 1) {
+        return encodePrintableKey(input);
+    }
+    switch (key) {
+        case "Enter": {
+            const mod = modifierParam(input);
+            if (mod > 1 && shouldUseWin32InputMode(input, options)) {
+                return encodeWin32EnterKeyInput(input);
+            }
+            if (mod > 1 && shouldUseKittyKeyboardMode(input, options)) {
+                return `\x1b[13;${mod}u`;
+            }
+            return "\r";
+        }
+        case "Tab":
+            if (input.shift && !input.ctrl && !input.alt && !input.meta) {
+                return "\x1b[Z";
+            }
+            return applyAltLikePrefix("\t", input);
+        case "Backspace":
+            return applyAltLikePrefix("\x7f", input);
+        case "Escape":
+            return "\x1b";
+        default:
+            break;
+    }
+    const nav = encodeNavigationKey(key, input);
+    if (nav !== null)
+        return nav;
+    const fn = encodeFunctionKey(key, input);
+    if (fn !== null)
+        return fn;
+    return "";
+}
+//# sourceMappingURL=terminal-key-input.js.map

package/dist/terminal-profiles.d.ts

@@ -0,0 +1,6 @@
+import type { TerminalProfile } from "./messages.js";
+export declare const DEFAULT_TERMINAL_PROFILES: readonly TerminalProfile[];
+export declare function guessTerminalProfileIcon(command: string): string | undefined;
+export declare function getTerminalProfileIcon(profile: TerminalProfile): string | undefined;
+export declare function resolveTerminalProfiles(terminalProfiles: TerminalProfile[] | undefined): readonly TerminalProfile[];
+//# sourceMappingURL=terminal-profiles.d.ts.map

package/dist/terminal-profiles.js

@@ -0,0 +1,28 @@
+import { KNOWN_PROVIDER_ICON_NAMES } from "./provider-icon-names.js";
+export const DEFAULT_TERMINAL_PROFILES = [
+    { id: "claude", name: "Claude Code", command: "claude", icon: "claude" },
+    { id: "codex", name: "Codex", command: "codex", icon: "codex" },
+    { id: "opencode", name: "OpenCode", command: "opencode", icon: "opencode" },
+];
+const WELL_KNOWN_COMMAND_ICONS = new Map(KNOWN_PROVIDER_ICON_NAMES.map((name) => [name, name]));
+function getCommandBaseName(command) {
+    const lastSlash = command.lastIndexOf("/");
+    const lastBackslash = command.lastIndexOf("\\");
+    const start = Math.max(lastSlash, lastBackslash) + 1;
+    const base = command.slice(start).toLowerCase();
+    const dotIndex = base.indexOf(".");
+    return dotIndex > 0 ? base.slice(0, dotIndex) : base;
+}
+export function guessTerminalProfileIcon(command) {
+    return WELL_KNOWN_COMMAND_ICONS.get(getCommandBaseName(command));
+}
+export function getTerminalProfileIcon(profile) {
+    return profile.icon ?? guessTerminalProfileIcon(profile.command);
+}
+export function resolveTerminalProfiles(terminalProfiles) {
+    if (terminalProfiles === undefined) {
+        return DEFAULT_TERMINAL_PROFILES;
+    }
+    return terminalProfiles;
+}
+//# sourceMappingURL=terminal-profiles.js.map

package/dist/terminal-snapshot.d.ts

@@ -0,0 +1,3 @@
+import type { TerminalState } from "./messages.js";
+export declare function renderTerminalSnapshotToAnsi(state: TerminalState): string;
+//# sourceMappingURL=terminal-snapshot.d.ts.map

package/dist/terminal-snapshot.js

@@ -0,0 +1,178 @@
+const DEFAULT_STYLE = {
+    fg: undefined,
+    bg: undefined,
+    fgMode: undefined,
+    bgMode: undefined,
+    bold: false,
+    italic: false,
+    underline: false,
+    dim: false,
+    inverse: false,
+    strikethrough: false,
+};
+export function renderTerminalSnapshotToAnsi(state) {
+    const rows = [...state.scrollback, ...state.grid];
+    const wrapFlags = [...(state.scrollbackWrapped ?? []), ...(state.gridWrapped ?? [])];
+    // Soft-wrapped lines can only be re-wrapped on resize when we know which rows
+    // were continuations. With that per-row flag we replay each logical line as one
+    // unbroken run (autowrap on) so xterm marks the continuations wrapped and reflows
+    // them. Without it (old daemon) we keep the verbatim per-row replay: autowrap off
+    // plus a hard newline per row.
+    const hasWrapInfo = wrapFlags.length === rows.length;
+    const lines = hasWrapInfo ? [] : ["\u001b[?7l"];
+    for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
+        const row = rows[rowIndex] ?? [];
+        const continuesToNextRow = hasWrapInfo && wrapFlags[rowIndex] === true;
+        // A continuation row must fill the full width so the next row first cell
+        // triggers xterm auto-wrap, which is what marks the row wrapped/reflowable.
+        lines.push(renderTerminalRow(row, continuesToNextRow ? state.cols : undefined));
+        if (rowIndex < rows.length - 1 && !continuesToNextRow) {
+            lines.push("\r\n");
+        }
+    }
+    lines.push("\u001b[0m");
+    const cursorPresentationAnsi = renderCursorPresentationToAnsi(state.cursor);
+    if (cursorPresentationAnsi) {
+        lines.push(cursorPresentationAnsi);
+    }
+    lines.push(`\u001b[${state.cursor.row + 1};${state.cursor.col + 1}H`);
+    lines.push(state.cursor.hidden ? "\u001b[?25l" : "\u001b[?25h");
+    if (!hasWrapInfo) {
+        lines.push("\u001b[?7h");
+    }
+    return lines.join("");
+}
+function renderCursorPresentationToAnsi(cursor) {
+    if (!cursor.style) {
+        return null;
+    }
+    const cursorStyleCode = (() => {
+        if (cursor.style === "block") {
+            return cursor.blink === false ? 2 : 1;
+        }
+        if (cursor.style === "underline") {
+            return cursor.blink === false ? 4 : 3;
+        }
+        return cursor.blink === false ? 6 : 5;
+    })();
+    return `\u001b[${cursorStyleCode} q`;
+}
+function renderTerminalRow(row, padToCols) {
+    const output = [];
+    const contentLength = getTerminalRowLength(row);
+    const length = padToCols !== undefined ? Math.max(contentLength, padToCols) : contentLength;
+    let previousStyle = DEFAULT_STYLE;
+    for (let index = 0; index < length; index += 1) {
+        const cell = row[index] ?? { char: " " };
+        const nextStyle = getTerminalStyle(cell);
+        if (!terminalStylesEqual(previousStyle, nextStyle)) {
+            output.push(styleToAnsi(nextStyle));
+            previousStyle = nextStyle;
+        }
+        output.push(cell.char || " ");
+    }
+    if (!terminalStylesEqual(previousStyle, DEFAULT_STYLE)) {
+        output.push("\u001b[0m");
+    }
+    return output.join("");
+}
+function getTerminalRowLength(row) {
+    for (let index = row.length - 1; index >= 0; index -= 1) {
+        const cell = row[index];
+        if (!cell) {
+            continue;
+        }
+        if (cell.char !== " ") {
+            return index + 1;
+        }
+        if (cell.fg !== undefined ||
+            cell.bg !== undefined ||
+            cell.fgMode !== undefined ||
+            cell.bgMode !== undefined ||
+            cell.bold ||
+            cell.italic ||
+            cell.underline ||
+            cell.dim ||
+            cell.inverse ||
+            cell.strikethrough) {
+            return index + 1;
+        }
+    }
+    return 0;
+}
+function getTerminalStyle(cell) {
+    return {
+        fg: cell.fg,
+        bg: cell.bg,
+        fgMode: cell.fgMode,
+        bgMode: cell.bgMode,
+        bold: Boolean(cell.bold),
+        italic: Boolean(cell.italic),
+        underline: Boolean(cell.underline),
+        dim: Boolean(cell.dim),
+        inverse: Boolean(cell.inverse),
+        strikethrough: Boolean(cell.strikethrough),
+    };
+}
+function terminalStylesEqual(left, right) {
+    return (left.fg === right.fg &&
+        left.bg === right.bg &&
+        left.fgMode === right.fgMode &&
+        left.bgMode === right.bgMode &&
+        left.bold === right.bold &&
+        left.italic === right.italic &&
+        left.underline === right.underline &&
+        left.dim === right.dim &&
+        left.inverse === right.inverse &&
+        left.strikethrough === right.strikethrough);
+}
+function styleToAnsi(style) {
+    const codes = ["0"];
+    if (style.bold) {
+        codes.push("1");
+    }
+    if (style.dim) {
+        codes.push("2");
+    }
+    if (style.italic) {
+        codes.push("3");
+    }
+    if (style.underline) {
+        codes.push("4");
+    }
+    if (style.inverse) {
+        codes.push("7");
+    }
+    if (style.strikethrough) {
+        codes.push("9");
+    }
+    if (style.fg !== undefined && style.fgMode !== undefined) {
+        codes.push(...colorToSgr(style.fgMode, style.fg, false));
+    }
+    if (style.bg !== undefined && style.bgMode !== undefined) {
+        codes.push(...colorToSgr(style.bgMode, style.bg, true));
+    }
+    return `\u001b[${codes.join(";")}m`;
+}
+function colorToSgr(mode, value, background) {
+    if (mode === 1) {
+        if (value >= 8) {
+            return [String((background ? 100 : 90) + (value - 8))];
+        }
+        return [String((background ? 40 : 30) + value)];
+    }
+    if (mode === 2) {
+        return [background ? "48" : "38", "5", String(value)];
+    }
+    if (mode === 3) {
+        return [
+            background ? "48" : "38",
+            "2",
+            String((value >> 16) & 0xff),
+            String((value >> 8) & 0xff),
+            String(value & 0xff),
+        ];
+    }
+    return [];
+}
+//# sourceMappingURL=terminal-snapshot.js.map

package/dist/terminal-stream-protocol.d.ts

@@ -0,0 +1,2 @@
+export * from "./binary-frames/terminal.js";
+//# sourceMappingURL=terminal-stream-protocol.d.ts.map

package/dist/terminal-stream-protocol.js

@@ -0,0 +1,2 @@
+export * from "./binary-frames/terminal.js";
+//# sourceMappingURL=terminal-stream-protocol.js.map

package/dist/terminal-subscription-key.d.ts

@@ -0,0 +1,2 @@
+export declare function terminalSubscriptionKey(cwd: string, workspaceId: string | undefined): string;
+//# sourceMappingURL=terminal-subscription-key.d.ts.map

package/dist/terminal-subscription-key.js

@@ -0,0 +1,9 @@
+// A terminal directory subscription is scoped to a (cwd, workspaceId) pair, not
+// cwd alone: under Model B two workspaces can share a cwd, and each must track
+// and tear down its own live subscription without disturbing the other. An
+// absent workspaceId (old clients) keys to the cwd on its own. The `::`
+// separator cannot collide with a workspace id, which is always `wks_<hex>`.
+export function terminalSubscriptionKey(cwd, workspaceId) {
+    return workspaceId === undefined ? cwd : `${workspaceId}::${cwd}`;
+}
+//# sourceMappingURL=terminal-subscription-key.js.map

package/dist/tool-call-display.d.ts

@@ -0,0 +1,11 @@
+import type { ToolCallTimelineItem } from "./agent-types.js";
+export type ToolCallDisplayInput = Pick<ToolCallTimelineItem, "name" | "status" | "error" | "metadata" | "detail"> & {
+    cwd?: string;
+};
+export interface ToolCallDisplayModel {
+    displayName: string;
+    summary?: string;
+    errorText?: string;
+}
+export declare function buildToolCallDisplayModel(input: ToolCallDisplayInput): ToolCallDisplayModel;
+//# sourceMappingURL=tool-call-display.d.ts.map