@otto-code/protocol 0.8.12 → 0.8.13

package/dist/terminal-input-mode.js

@@ -1,9 +1,13 @@
 export const DEFAULT_TERMINAL_INPUT_MODE_STATE = {
     kittyKeyboardFlags: 0,
     win32InputMode: false,
+    applicationCursorKeys: false,
+    bracketedPaste: false,
 };
 const ESC = String.fromCharCode(0x1b);
+const APPLICATION_CURSOR_KEYS_MODE = 1;
 const WIN32_INPUT_MODE = 9001;
+const BRACKETED_PASTE_MODE = 2004;
 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) {
@@ -34,12 +38,16 @@ export function terminalInputModeSupportsModifiedEnter(state) {
 }
 export function terminalInputModeStatesEqual(left, right) {
     return (left.kittyKeyboardFlags === right.kittyKeyboardFlags &&
-        left.win32InputMode === right.win32InputMode);
+        left.win32InputMode === right.win32InputMode &&
+        Boolean(left.applicationCursorKeys) === Boolean(right.applicationCursorKeys) &&
+        Boolean(left.bracketedPaste) === Boolean(right.bracketedPaste));
 }
 export class TerminalInputModeTracker {
     constructor() {
         this.kittyKeyboardFlags = 0;
         this.win32InputMode = false;
+        this.applicationCursorKeys = false;
+        this.bracketedPaste = false;
         this.kittyKeyboardStack = [];
         this.pending = "";
     }
@@ -80,6 +88,8 @@ export class TerminalInputModeTracker {
     reset() {
         this.kittyKeyboardFlags = 0;
         this.win32InputMode = false;
+        this.applicationCursorKeys = false;
+        this.bracketedPaste = false;
         this.kittyKeyboardStack.length = 0;
         this.pending = "";
     }
@@ -87,6 +97,8 @@ export class TerminalInputModeTracker {
         return {
             kittyKeyboardFlags: this.kittyKeyboardFlags,
             win32InputMode: this.win32InputMode,
+            applicationCursorKeys: this.applicationCursorKeys,
+            bracketedPaste: this.bracketedPaste,
         };
     }
     getKittyKeyboardFlags() {
@@ -103,6 +115,12 @@ export class TerminalInputModeTracker {
         if (this.win32InputMode) {
             parts.push("\x1b[?9001h");
         }
+        if (this.applicationCursorKeys) {
+            parts.push("\x1b[?1h");
+        }
+        if (this.bracketedPaste) {
+            parts.push("\x1b[?2004h");
+        }
         return parts.join("");
     }
     applyKittyKeyboardSequence(prefix, params) {
@@ -140,12 +158,23 @@ export class TerminalInputModeTracker {
     }
     applyPrivateModeSequence(params, final) {
         const modes = parsePrivateModeParams(params);
-        if (!modes.has(WIN32_INPUT_MODE)) {
-            return false;
+        let changed = false;
+        if (modes.has(WIN32_INPUT_MODE)) {
+            const previous = this.win32InputMode;
+            this.win32InputMode = final === "h";
+            changed = this.win32InputMode !== previous || changed;
+        }
+        if (modes.has(APPLICATION_CURSOR_KEYS_MODE)) {
+            const previous = this.applicationCursorKeys;
+            this.applicationCursorKeys = final === "h";
+            changed = this.applicationCursorKeys !== previous || changed;
+        }
+        if (modes.has(BRACKETED_PASTE_MODE)) {
+            const previous = this.bracketedPaste;
+            this.bracketedPaste = final === "h";
+            changed = this.bracketedPaste !== previous || changed;
         }
-        const previous = this.win32InputMode;
-        this.win32InputMode = final === "h";
-        return this.win32InputMode !== previous;
+        return changed;
     }
 }
 //# sourceMappingURL=terminal-input-mode.js.map

package/dist/terminal-key-input.js

@@ -99,6 +99,9 @@ function csiWithModifier(finalByte, input) {
     const mod = modifierParam(input);
     return mod === 1 ? `\x1b[${finalByte}` : `\x1b[1;${mod}${finalByte}`;
 }
+function ss3WithModifier(finalByte, input) {
+    return modifierParam(input) === 1 ? `\x1bO${finalByte}` : csiWithModifier(finalByte, input);
+}
 function csiTilde(base, input) {
     const mod = modifierParam(input);
     return mod === 1 ? `\x1b[${base}~` : `\x1b[${base};${mod}~`;
@@ -133,16 +136,22 @@ function encodeFunctionKey(key, input) {
             return null;
     }
 }
-function encodeNavigationKey(key, input) {
+function encodeArrowKey(finalByte, input, options) {
+    if (options.inputMode?.applicationCursorKeys) {
+        return ss3WithModifier(finalByte, input);
+    }
+    return csiWithModifier(finalByte, input);
+}
+function encodeNavigationKey(key, input, options) {
     switch (key) {
         case "ArrowUp":
-            return csiWithModifier("A", input);
+            return encodeArrowKey("A", input, options);
         case "ArrowDown":
-            return csiWithModifier("B", input);
+            return encodeArrowKey("B", input, options);
         case "ArrowRight":
-            return csiWithModifier("C", input);
+            return encodeArrowKey("C", input, options);
         case "ArrowLeft":
-            return csiWithModifier("D", input);
+            return encodeArrowKey("D", input, options);
         case "Home":
             return csiWithModifier("H", input);
         case "End":
@@ -190,7 +199,7 @@ export function encodeTerminalKeyInput(input, options = {}) {
         default:
             break;
     }
-    const nav = encodeNavigationKey(key, input);
+    const nav = encodeNavigationKey(key, input, options);
     if (nav !== null)
         return nav;
     const fn = encodeFunctionKey(key, input);

package/dist/terminal-profiles.d.ts

@@ -1,5 +1,40 @@
 import type { TerminalProfile } from "./messages.js";
+/**
+ * Marks where a typed prompt goes inside a profile's `command` or `args`. A
+ * profile carrying it accepts a prompt; one without it launches as-is.
+ *
+ * Substitution happens client-side before `create_terminal_request` is sent, so
+ * this is profile-format vocabulary rather than anything on the wire. It lives
+ * here because this module owns what a `TerminalProfile` means.
+ */
+export declare const PROMPT_SENTINEL = "{{{prompt}}}";
 export declare const DEFAULT_TERMINAL_PROFILES: readonly TerminalProfile[];
+export interface SubstitutableCommand {
+    command: string;
+    args?: string[];
+}
+export interface ResolvedCommand {
+    command: string;
+    args: string[];
+}
+/** True when the sentinel appears anywhere in `command` or an `args` entry. */
+export declare function profileTakesPrompt(profile: SubstitutableCommand): boolean;
+/** Replaces every sentinel occurrence with `prompt`, dropping prompt-only args when there is none. */
+export declare function substitutePrompt(profile: SubstitutableCommand, prompt: string): ResolvedCommand;
+/** Human-readable preview of the resolved command, for read-only display. */
+export declare function formatResolvedCommand(resolved: ResolvedCommand): string;
+export interface TerminalProfileLaunch {
+    name: string;
+    command: string;
+    args: string[];
+}
+/**
+ * What to spawn for a profile. Every launcher goes through here, so no caller
+ * can forward a raw `profile.args` still carrying the sentinel: launchers with
+ * nowhere to type (pinned targets, the workspace terminal menu) pass an empty
+ * prompt and get the bare command back.
+ */
+export declare function resolveTerminalProfileLaunch(profile: TerminalProfile, prompt: string): TerminalProfileLaunch;
 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[];

package/dist/terminal-profiles.js

@@ -1,9 +1,78 @@
 import { KNOWN_PROVIDER_ICON_NAMES } from "./provider-icon-names.js";
+/**
+ * Marks where a typed prompt goes inside a profile's `command` or `args`. A
+ * profile carrying it accepts a prompt; one without it launches as-is.
+ *
+ * Substitution happens client-side before `create_terminal_request` is sent, so
+ * this is profile-format vocabulary rather than anything on the wire. It lives
+ * here because this module owns what a `TerminalProfile` means.
+ */
+export const PROMPT_SENTINEL = "{{{prompt}}}";
+// Prompt forms are taken from each CLI's own `--help`. claude, codex, and pi
+// take the prompt as a trailing positional. opencode's positional is the
+// project directory, so its prompt goes through `--prompt`, written in the
+// `--flag=value` form to keep it one argv entry that can be dropped whole when
+// no prompt is typed.
 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" },
+    { id: "claude", name: "Claude Code", command: "claude", args: [PROMPT_SENTINEL], icon: "claude" },
+    { id: "codex", name: "Codex", command: "codex", args: [PROMPT_SENTINEL], icon: "codex" },
+    {
+        id: "opencode",
+        name: "OpenCode",
+        command: "opencode",
+        args: [`--prompt=${PROMPT_SENTINEL}`],
+        icon: "opencode",
+    },
+    { id: "pi", name: "Pi", command: "pi", args: [PROMPT_SENTINEL], icon: "pi" },
 ];
+function containsSentinel(value) {
+    return value.includes(PROMPT_SENTINEL);
+}
+/** True when the sentinel appears anywhere in `command` or an `args` entry. */
+export function profileTakesPrompt(profile) {
+    return containsSentinel(profile.command) || (profile.args ?? []).some(containsSentinel);
+}
+function replaceSentinel(value, prompt) {
+    return value.split(PROMPT_SENTINEL).join(prompt);
+}
+/**
+ * An arg that exists only to carry a prompt: the sentinel alone
+ * (`{{{prompt}}}`), or as the whole value of an option assignment
+ * (`--prompt={{{prompt}}}`). Both are dropped when there is no prompt, because
+ * an empty positional and a valueless `--prompt=` are not the same as omitting
+ * them. A sentinel embedded in larger text (`echo {{{prompt}}}`) is not
+ * prompt-only and still substitutes to empty.
+ *
+ * This is why an option and its value belong in one entry. Split across two,
+ * the option would survive with nothing to carry.
+ */
+function isPromptOnlyArg(arg) {
+    if (arg === PROMPT_SENTINEL) {
+        return true;
+    }
+    const separator = arg.indexOf("=");
+    return separator > 0 && arg.slice(separator + 1) === PROMPT_SENTINEL;
+}
+/** Replaces every sentinel occurrence with `prompt`, dropping prompt-only args when there is none. */
+export function substitutePrompt(profile, prompt) {
+    return {
+        command: replaceSentinel(profile.command, prompt),
+        args: (profile.args ?? []).flatMap((arg) => prompt === "" && isPromptOnlyArg(arg) ? [] : [replaceSentinel(arg, prompt)]),
+    };
+}
+/** Human-readable preview of the resolved command, for read-only display. */
+export function formatResolvedCommand(resolved) {
+    return [resolved.command, ...resolved.args].join(" ");
+}
+/**
+ * What to spawn for a profile. Every launcher goes through here, so no caller
+ * can forward a raw `profile.args` still carrying the sentinel: launchers with
+ * nowhere to type (pinned targets, the workspace terminal menu) pass an empty
+ * prompt and get the bare command back.
+ */
+export function resolveTerminalProfileLaunch(profile, prompt) {
+    return { name: profile.name, ...substitutePrompt(profile, prompt) };
+}
 const WELL_KNOWN_COMMAND_ICONS = new Map(KNOWN_PROVIDER_ICON_NAMES.map((name) => [name, name]));
 function getCommandBaseName(command) {
     const lastSlash = command.lastIndexOf("/");
@@ -19,10 +88,183 @@ export function guessTerminalProfileIcon(command) {
 export function getTerminalProfileIcon(profile) {
     return profile.icon ?? guessTerminalProfileIcon(profile.command);
 }
+// Base command name to the sentinel-bearing args that command wants, derived
+// from the shipped defaults rather than written out again, so adding a default
+// profile later cannot silently miss the adoption below or get the wrong form.
+const PROMPT_ARGS_BY_COMMAND = new Map(DEFAULT_TERMINAL_PROFILES.map((profile) => [
+    getCommandBaseName(profile.command),
+    (profile.args ?? []).filter(containsSentinel),
+]));
+// Adoption applies only to the interactive, prompt-taking form of each CLI.
+// These are the global options whose values would otherwise look positional
+// while walking argv. Unknown options stay conservative: a following bare arg
+// blocks adoption rather than risking a second prompt or changing a subcommand.
+const GLOBAL_OPTIONS_WITH_VALUES_BY_COMMAND = new Map([
+    [
+        "claude",
+        new Set([
+            "--add-dir",
+            "--agent",
+            "--agents",
+            "--allowed-tools",
+            "--allowedTools",
+            "--append-system-prompt",
+            "--betas",
+            "--debug-file",
+            "--disallowed-tools",
+            "--disallowedTools",
+            "--effort",
+            "--fallback-model",
+            "--file",
+            "--input-format",
+            "--json-schema",
+            "--max-budget-usd",
+            "--mcp-config",
+            "--model",
+            "--name",
+            "--output-format",
+            "--permission-mode",
+            "--plugin-dir",
+            "--plugin-url",
+            "--remote-control-session-name-prefix",
+            "--settings",
+            "--system-prompt",
+            "--system-prompt-file",
+            "--tools",
+            "-n",
+        ]),
+    ],
+    [
+        "codex",
+        new Set([
+            "--add-dir",
+            "--ask-for-approval",
+            "--cd",
+            "--config",
+            "--disable",
+            "--enable",
+            "--image",
+            "--local-provider",
+            "--model",
+            "--profile",
+            "--remote",
+            "--remote-auth-token-env",
+            "--sandbox",
+            "-C",
+            "-a",
+            "-c",
+            "-i",
+            "-m",
+            "-p",
+            "-s",
+        ]),
+    ],
+    [
+        "opencode",
+        new Set([
+            "--agent",
+            "--cors",
+            "--hostname",
+            "--log-level",
+            "--mdns-domain",
+            "--model",
+            "--port",
+            "--prompt",
+            "--replay-limit",
+            "--session",
+            "-m",
+            "-s",
+        ]),
+    ],
+    [
+        "pi",
+        new Set([
+            "--api-key",
+            "--append-system-prompt",
+            "--exclude-tools",
+            "--export",
+            "--extension",
+            "--fork",
+            "--mode",
+            "--model",
+            "--models",
+            "--name",
+            "--prompt-template",
+            "--provider",
+            "--session",
+            "--session-dir",
+            "--session-id",
+            "--skill",
+            "--system-prompt",
+            "--theme",
+            "--thinking",
+            "--tools",
+            "-e",
+            "-n",
+            "-t",
+            "-xt",
+        ]),
+    ],
+]);
+// Profiles predating the sentinel got materialized into user config the first
+// time anyone touched the profile list (host-page.tsx patches the whole list on
+// any add, edit, or reorder). Those users would otherwise be stuck with
+// launch-only versions of the agents we ship, while a fresh install gets prompt
+// support, so a profile still pointing at one of those agents adopts the
+// trailing sentinel on read.
+//
+// Keyed on the command's base name, not the profile id: profiles created
+// through the settings UI get generated ids (`profile_<timestamp>_<random>`),
+// so a real user's Codex profile is never id `codex`. The base name also
+// normalizes `/usr/local/bin/codex` and `codex.cmd` onto the same agent.
+//
+// User args are preserved: `codex --yolo` becomes `codex --yolo {{{prompt}}}`.
+// The appended form comes from the shipped default for that command, so
+// opencode gets `--prompt=` rather than a trailing positional, which it would
+// read as a project directory. A profile that already carries the sentinel
+// anywhere is left alone, and so is one pointing at any other command. Nothing
+// is written back, so this stays a read-time adoption with no version stamp and
+// no daemon-start hook.
+// Any positional means this is not the bare interactive form we can safely
+// adopt. It may be a subcommand (`codex --profile work login`) or an existing
+// prompt/project argument. Option assignments carry their value inline; known
+// split options consume the next argv entry before positional detection.
+function hasPositionalArg(command, args) {
+    const optionsWithValues = GLOBAL_OPTIONS_WITH_VALUES_BY_COMMAND.get(command) ?? new Set();
+    let expectsOptionValue = false;
+    for (const arg of args) {
+        if (expectsOptionValue) {
+            expectsOptionValue = false;
+            continue;
+        }
+        if (arg === "--") {
+            return true;
+        }
+        if (!arg.startsWith("-")) {
+            return true;
+        }
+        const separator = arg.indexOf("=");
+        const option = separator === -1 ? arg : arg.slice(0, separator);
+        expectsOptionValue = separator === -1 && optionsWithValues.has(option);
+    }
+    return false;
+}
+function adoptPromptSentinel(profile) {
+    const command = getCommandBaseName(profile.command);
+    const promptArgs = PROMPT_ARGS_BY_COMMAND.get(command);
+    if (!promptArgs || promptArgs.length === 0) {
+        return profile;
+    }
+    const args = profile.args ?? [];
+    if (profileTakesPrompt(profile) || hasPositionalArg(command, args)) {
+        return profile;
+    }
+    return { ...profile, args: [...args, ...promptArgs] };
+}
 export function resolveTerminalProfiles(terminalProfiles) {
     if (terminalProfiles === undefined) {
         return DEFAULT_TERMINAL_PROFILES;
     }
-    return terminalProfiles;
+    return terminalProfiles.map(adoptPromptSentinel);
 }
 //# sourceMappingURL=terminal-profiles.js.map

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

@@ -12,8 +12,8 @@ export interface ToolCallDisplayModel {
  * shows a tool/action name without a full timeline item to run through
  * {@link buildToolCallDisplayModel} (the visualizer's action labels, sub-agent
  * activity rows). Strips the MCP/Otto namespace, consults the known-tool
- * registry, then title-cases as a fallback - so "mcp__otto__spawn_task",
- * "otto.spawn_task", and a bare "spawn_task" all render as "Spawn Task".
+ * registry, then title-cases as a fallback - so "mcp__otto__suggest_task",
+ * "otto.suggest_task", and a bare "suggest_task" all render as "Suggest Task".
  */
 export declare function getToolDisplayName(name: string): string;
 export declare function buildToolCallDisplayModel(input: ToolCallDisplayInput): ToolCallDisplayModel;

package/dist/tool-call-display.js

@@ -11,7 +11,7 @@ function readString(value) {
 //
 // Only tools whose bare id does NOT title-case cleanly on its own need an entry
 // here: lowercase compound names ("websearch") a splitter can't segment, or
-// ones we want to word deliberately. Well-formed snake_case ("spawn_task") and
+// ones we want to word deliberately. Well-formed snake_case ("suggest_task") and
 // camelCase ("WebSearch") names are handled by the algorithmic humanizer below
 // and do NOT need listing.
 //
@@ -35,7 +35,7 @@ const KNOWN_TOOL_DISPLAY_NAMES = {
     ls: "List Files",
 };
 // Split camelCase / PascalCase and separator-delimited identifiers into words,
-// then Title-Case them: "WebSearch" -> "Web Search", "spawn_task" -> "Spawn
+// then Title-Case them: "WebSearch" -> "Web Search", "suggest_task" -> "Suggest
 // Task", "HTTPServer" -> "HTTP Server".
 function titleCaseToolId(value) {
     return value
@@ -52,8 +52,8 @@ function humanizeToolName(name) {
     if (!trimmed) {
         return name;
     }
-    // Strip the transport namespace first ("mcp__otto__spawn_task" ->
-    // "spawn_task", "otto.list_agents" -> "list_agents") so both the known-tool
+    // Strip the transport namespace first ("mcp__otto__suggest_task" ->
+    // "suggest_task", "otto.list_chats" -> "list_chats") so both the known-tool
     // lookup and the fallback operate on the bare tool id.
     const leaf = getMcpToolLeafName(trimmed) ?? getOttoToolLeafName(trimmed);
     if (leaf) {
@@ -66,8 +66,8 @@ function humanizeToolName(name) {
  * shows a tool/action name without a full timeline item to run through
  * {@link buildToolCallDisplayModel} (the visualizer's action labels, sub-agent
  * activity rows). Strips the MCP/Otto namespace, consults the known-tool
- * registry, then title-cases as a fallback - so "mcp__otto__spawn_task",
- * "otto.spawn_task", and a bare "spawn_task" all render as "Spawn Task".
+ * registry, then title-cases as a fallback - so "mcp__otto__suggest_task",
+ * "otto.suggest_task", and a bare "suggest_task" all render as "Suggest Task".
  */
 export function getToolDisplayName(name) {
     return humanizeToolName(name);