@camerontaylor/paseo-protocol 0.8.0-fork.1

package/dist/terminal-key-input.js

@@ -0,0 +1,210 @@
+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 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}~`;
+}
+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 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 encodeArrowKey("A", input, options);
+        case "ArrowDown":
+            return encodeArrowKey("B", input, options);
+        case "ArrowRight":
+            return encodeArrowKey("C", input, options);
+        case "ArrowLeft":
+            return encodeArrowKey("D", input, options);
+        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, options);
+    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,41 @@
+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[];
+//# sourceMappingURL=terminal-profiles.d.ts.map

package/dist/terminal-profiles.js

@@ -0,0 +1,270 @@
+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", 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("/");
+    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);
+}
+// 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.map(adoptPromptSentinel);
+}
+//# 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