@unlinearity/cli-wechat-bridge 1.1.6 → 1.2.1

package/dist/bridge/bridge-state.js

@@ -1,3 +1,9 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
 import fs from "node:fs";
 import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, appendBoundedLog, ensureWorkspaceChannelDir, ensureChannelDataDir, } from "../wechat/channel-config.js";
 import { buildInstanceId } from "../core/text-utils.js";
@@ -79,6 +85,9 @@ export function normalizeBridgeLockPayload(value) {
         startedAt: record.startedAt,
         lifecycle: record.lifecycle === "companion_bound" ? "companion_bound" : "persistent",
         legacyLifecycleFallback: hasExplicitLifecycle ? undefined : true,
+        ...(record.channelId === "wechat" || record.channelId === "wecom"
+            ? { channelId: record.channelId }
+            : {}),
     };
 }
 export function readBridgeLockFile() {
@@ -148,11 +157,13 @@ function buildLockConflictError(lock) {
  * pid is alive but belongs to something else, and "unknown" when the command
  * line could not be resolved (probe failure, restricted permissions).
  */
-export function classifyLockHolderProcess(pid) {
-    if (!isPidAlive(pid)) {
+export function classifyLockHolderProcess(pid, dependencies = {}) {
+    const isProcessAlive = dependencies.isPidAlive ?? isPidAlive;
+    const getProcessRecord = dependencies.getProcessRecordByPid ?? getProcessRecordByPid;
+    if (!isProcessAlive(pid)) {
         return "unknown";
     }
-    const record = getProcessRecordByPid(pid);
+    const record = getProcessRecord(pid);
     if (!record) {
         return "unknown";
     }
@@ -200,6 +211,7 @@ export class BridgeStateStore {
             cwd: options.cwd,
             startedAt: new Date(this.bridgeStartedAtMs).toISOString(),
             lifecycle: options.lifecycle,
+            channelId: options.channelId,
         };
         this.acquireLock();
         const shouldRestoreSessionState = options.sessionStartMode !== "new";
@@ -231,6 +243,7 @@ export class BridgeStateStore {
             resumeConversationId: persistedResumeConversationId,
             transcriptPath: persistedTranscriptPath,
             lastActivityAt: persisted?.lastActivityAt,
+            channelId: options.channelId,
             pendingConfirmation: null,
             pendingUserInput: null,
         };

package/dist/bridge/bridge-utils.js

@@ -1,3 +1,9 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -1113,37 +1119,6 @@ export function isStrictApprovalModeEnabled(env = process.env) {
     const value = env.CLI_BRIDGE_STRICT_APPROVAL?.trim().toLowerCase();
     return value === "1" || value === "true" || value === "yes" || value === "on";
 }
-// Outbound WeChat text size cap shared by the streaming OutputBatcher and the
-// final-reply forwarder. Long replies sent as a single sendmessage call can be
-// rejected by the server, which previously made long final replies vanish.
-export const WECHAT_TEXT_CHUNK_MAX_CHARS = 1_200;
-export function splitWechatTextIntoChunks(text, maxChars = WECHAT_TEXT_CHUNK_MAX_CHARS) {
-    const normalized = text.trim();
-    if (!normalized) {
-        return [];
-    }
-    if (normalized.length <= maxChars) {
-        return [normalized];
-    }
-    const chunks = [];
-    let remaining = normalized;
-    while (remaining.length > maxChars) {
-        // Prefer breaking at a newline reasonably close to the cap so paragraphs
-        // stay intact; fall back to a hard split.
-        const window = remaining.slice(0, maxChars + 1);
-        const newlineIndex = window.lastIndexOf("\n");
-        const splitIndex = newlineIndex > maxChars / 2 ? newlineIndex : maxChars;
-        const chunk = remaining.slice(0, splitIndex).trim();
-        if (chunk) {
-            chunks.push(chunk);
-        }
-        remaining = remaining.slice(splitIndex).trim();
-    }
-    if (remaining) {
-        chunks.push(remaining);
-    }
-    return chunks;
-}
 export function shouldDropStartupBacklogMessage(createdAtMs, bridgeStartedAtMs, graceMs = MESSAGE_START_GRACE_MS) {
     // A missing or unparsable timestamp must not drop the message: treat it as
     // fresh and let normal processing continue.

package/dist/bridge/claude-hook.js

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
 import crypto from "node:crypto";
 import net from "node:net";
 async function readStdin() {

package/dist/bridge/claude-native-controls.js

@@ -0,0 +1,145 @@
+import { NativeTerminalControl, parseClaudeModelPicker, parseClaudeModelSwitchConfirmation, readClaudePermissionMode } from "./native-terminal-control.js";
+export class ClaudeNativeControls {
+    previousMode = null;
+    terminal;
+    session;
+    constructor(terminal, session) {
+        this.terminal = terminal;
+        this.session = session;
+    }
+    assertPrompt() {
+        if (readClaudePermissionMode(this.terminal.text) === null) {
+            throw new Error("Claude must be at an empty native prompt before changing models or plan mode.");
+        }
+    }
+    async listModels() {
+        return this.terminal.run(async () => {
+            this.assertPrompt();
+            await this.terminal.openMenu("/model", "Select model");
+            const options = new Map();
+            const visited = new Set();
+            const initial = parseClaudeModelPicker(this.terminal.text).find((option) => option.focused)?.index;
+            while (true) {
+                const rows = parseClaudeModelPicker(this.terminal.text);
+                for (const row of rows) {
+                    options.set(row.index, {
+                        id: JSON.stringify({ index: row.index, label: row.label }),
+                        displayName: row.label,
+                        isCurrent: row.current || row.index === initial,
+                    });
+                }
+                const focused = rows.find((row) => row.focused);
+                if (!focused)
+                    throw new Error("Could not identify the focused Claude model. Close the menu and try again.");
+                if (visited.has(focused.index))
+                    break;
+                visited.add(focused.index);
+                await this.terminal.key("\u001b[B");
+            }
+            // A clamped selector can start in the middle; walk upwards to capture earlier hidden rows too.
+            const visitedUp = new Set();
+            while (true) {
+                const rows = parseClaudeModelPicker(this.terminal.text);
+                for (const row of rows) {
+                    options.set(row.index, { id: JSON.stringify({ index: row.index, label: row.label }), displayName: row.label, isCurrent: row.current || row.index === initial });
+                }
+                const focused = rows.find((row) => row.focused);
+                if (!focused)
+                    throw new Error("Could not identify the focused Claude model.");
+                if (visitedUp.has(focused.index))
+                    break;
+                visitedUp.add(focused.index);
+                if (focused.index === 1)
+                    break;
+                await this.terminal.key("\u001b[A");
+            }
+            await this.terminal.closeMenu();
+            return [...options.entries()].filter(([index]) => visited.has(index) || visitedUp.has(index)).sort(([a], [b]) => a - b).map(([, option]) => option);
+        });
+    }
+    async selectModel(id) {
+        const target = JSON.parse(id);
+        if (!Number.isSafeInteger(target.index) || target.index < 1 || typeof target.label !== "string")
+            throw new Error("Invalid Claude model selection. Send /model again.");
+        return this.terminal.run(async () => {
+            this.assertPrompt();
+            await this.terminal.openMenu("/model", "Select model");
+            const visited = new Set();
+            while (true) {
+                const focused = parseClaudeModelPicker(this.terminal.text).find((row) => row.focused);
+                if (!focused)
+                    throw new Error("Could not identify the focused Claude model.");
+                if (focused.index === target.index) {
+                    if (focused.label !== target.label)
+                        throw new Error("The Claude model list changed. Send /model again.");
+                    break;
+                }
+                if (visited.has(focused.index))
+                    throw new Error("The Claude model is no longer selectable. Send /model again.");
+                visited.add(focused.index);
+                await this.terminal.key(focused.index < target.index ? "\u001b[B" : "\u001b[A");
+            }
+            if (!/s to use this session only/i.test(this.terminal.text)) {
+                throw new Error("This Claude version does not expose session-only model selection. Update Claude Code and try again.");
+            }
+            await this.terminal.submitMenu(undefined, "s");
+            await this.terminal.waitFor(() => parseClaudeModelSwitchConfirmation(this.terminal.text) !== null || readClaudePermissionMode(this.terminal.text) !== null);
+            const confirmation = parseClaudeModelSwitchConfirmation(this.terminal.text);
+            if (confirmation) {
+                const targetLabel = target.label.toLowerCase();
+                const confirmedModel = confirmation.model.toLowerCase();
+                const matchesTarget = targetLabel.includes(confirmedModel)
+                    || (targetLabel.startsWith("default (recommended)") && confirmedModel.endsWith(" (default)"));
+                if (!confirmation.yesFocused || !matchesTarget) {
+                    throw new Error("Claude displayed an unexpected model switch confirmation. Check the visible terminal before trying again.");
+                }
+                await this.terminal.key("\r");
+                await this.terminal.waitFor(() => readClaudePermissionMode(this.terminal.text) !== null);
+            }
+            await this.terminal.openMenu("/model", "Select model");
+            const applied = parseClaudeModelPicker(this.terminal.text).find((row) => row.focused);
+            if (!applied || applied.label !== target.label || applied.index !== target.index)
+                throw new Error("Claude did not confirm the selected model.");
+            await this.terminal.closeMenu();
+            return { id, displayName: target.label, isCurrent: true };
+        });
+    }
+    async setPlanMode(enabled) {
+        return this.terminal.run(async () => {
+            this.assertPrompt();
+            const current = readClaudePermissionMode(this.terminal.text);
+            const session = this.session();
+            if (this.previousMode?.session !== session)
+                this.previousMode = null;
+            if (enabled) {
+                if (current === "plan")
+                    return true;
+                if (!["default", "acceptEdits", "bypassPermissions", "auto"].includes(current)) {
+                    throw new Error(`Claude cannot restore permission mode ${current} through the native mode switch.`);
+                }
+                await this.terminal.command("/plan");
+                await this.terminal.waitFor(() => readClaudePermissionMode(this.terminal.text) === "plan");
+                this.previousMode = { session, mode: current };
+                return true;
+            }
+            if (current !== "plan") {
+                this.previousMode = null;
+                return false;
+            }
+            const target = this.previousMode?.mode ?? "default";
+            const visited = new Set();
+            while (true) {
+                const mode = readClaudePermissionMode(this.terminal.text);
+                if (mode === target)
+                    break;
+                if (!mode || visited.has(mode))
+                    throw new Error(`Claude could not restore ${target}; check the native permission mode.`);
+                visited.add(mode);
+                await this.terminal.key("\u001b[Z");
+                await this.terminal.waitFor(() => readClaudePermissionMode(this.terminal.text) !== mode);
+            }
+            this.previousMode = null;
+            return false;
+        });
+    }
+}

package/dist/bridge/codex-visible-thread-proxy.js

@@ -0,0 +1,140 @@
+import { WebSocket, WebSocketServer } from "ws";
+export class CodexVisibleThreadProxy {
+    server;
+    clients = new Set();
+    upstreams = new Set();
+    constructor(options) {
+        this.server = new WebSocketServer({
+            host: "127.0.0.1",
+            port: 0,
+            verifyClient: ({ req }) => req.headers.authorization === `Bearer ${options.token}`,
+        });
+        this.server.on("connection", (client) => {
+            options.onTrace?.("client_connected");
+            const upstream = new WebSocket(options.upstreamUrl, {
+                headers: { Authorization: `Bearer ${options.token}` },
+            });
+            this.clients.add(client);
+            this.upstreams.add(upstream);
+            const pendingRequests = new Map();
+            const queued = [];
+            let queuedBytes = 0;
+            client.on("message", (data, binary) => {
+                const bytes = Buffer.from(data);
+                if (!binary) {
+                    try {
+                        const request = JSON.parse(bytes.toString("utf8"));
+                        if (request && typeof request === "object" && "method" in request) {
+                            if (typeof request.method === "string" &&
+                                (request.method.startsWith("thread/") || request.method === "turn/start")) {
+                                const params = "params" in request && request.params && typeof request.params === "object"
+                                    ? request.params : null;
+                                const threadId = params && "threadId" in params && typeof params.threadId === "string"
+                                    ? params.threadId.slice(0, 12) : "none";
+                                options.onTrace?.(`request method=${request.method} thread=${threadId}`);
+                            }
+                            if (request.method === "turn/start" && "params" in request &&
+                                request.params && typeof request.params === "object" &&
+                                "threadId" in request.params && typeof request.params.threadId === "string") {
+                                options.onVisibleTurn(request.params.threadId);
+                            }
+                            if ((request.method === "thread/resume" || request.method === "thread/start") &&
+                                "id" in request && (typeof request.id === "number" || typeof request.id === "string")) {
+                                pendingRequests.set(request.id, request.method);
+                            }
+                        }
+                    }
+                    catch {
+                        // Forward non-JSON messages unchanged.
+                    }
+                }
+                if (upstream.readyState === WebSocket.OPEN) {
+                    upstream.send(bytes, { binary });
+                }
+                else if (upstream.readyState === WebSocket.CONNECTING && queuedBytes + bytes.length <= 1_048_576) {
+                    queued.push({ data: bytes, binary });
+                    queuedBytes += bytes.length;
+                }
+                else {
+                    client.close();
+                }
+            });
+            upstream.on("open", () => {
+                for (const message of queued)
+                    upstream.send(message.data, { binary: message.binary });
+                queued.length = 0;
+            });
+            upstream.on("message", (data, binary) => {
+                if (!binary) {
+                    try {
+                        const response = JSON.parse(data.toString());
+                        const pendingMethod = response && typeof response === "object" && "id" in response &&
+                            (typeof response.id === "number" || typeof response.id === "string")
+                            ? pendingRequests.get(response.id) : undefined;
+                        if (pendingMethod && response && typeof response === "object" && "id" in response &&
+                            (typeof response.id === "number" || typeof response.id === "string")) {
+                            pendingRequests.delete(response.id);
+                            options.onTrace?.(`response method=${pendingMethod} success=${"result" in response}`);
+                        }
+                        if (pendingMethod && response && typeof response === "object" && "result" in response &&
+                            response.result && typeof response.result === "object" &&
+                            "thread" in response.result && response.result.thread &&
+                            typeof response.result.thread === "object" && "id" in response.result.thread &&
+                            typeof response.result.thread.id === "string" &&
+                            !("parentThreadId" in response.result.thread &&
+                                typeof response.result.thread.parentThreadId === "string") &&
+                            !("ephemeral" in response.result.thread && response.result.thread.ephemeral === true)) {
+                            const cwd = "cwd" in response.result.thread && typeof response.result.thread.cwd === "string"
+                                ? response.result.thread.cwd
+                                : undefined;
+                            options.onTrace?.(`opened thread=${response.result.thread.id.slice(0, 12)} cwd=${cwd ?? "unknown"}`);
+                            options.onThreadOpened(response.result.thread.id, cwd);
+                        }
+                    }
+                    catch {
+                        // A malformed response must not interrupt the visible client.
+                    }
+                }
+                if (client.readyState === WebSocket.OPEN)
+                    client.send(data, { binary });
+            });
+            client.on("close", () => upstream.terminate());
+            upstream.on("close", () => client.close());
+            client.on("error", () => upstream.terminate());
+            upstream.on("error", () => client.close());
+            client.on("close", () => {
+                this.clients.delete(client);
+                options.onTrace?.("client_disconnected");
+            });
+            upstream.on("close", () => this.upstreams.delete(upstream));
+        });
+    }
+    static async start(options) {
+        const proxy = new CodexVisibleThreadProxy(options);
+        try {
+            await new Promise((resolve, reject) => {
+                proxy.server.once("listening", resolve);
+                proxy.server.once("error", reject);
+            });
+            return proxy;
+        }
+        catch (error) {
+            proxy.server.close();
+            throw error;
+        }
+    }
+    get connected() {
+        return this.clients.size > 0;
+    }
+    get url() {
+        const address = this.server.address();
+        return `ws://127.0.0.1:${address.port}`;
+    }
+    async close() {
+        for (const client of this.clients)
+            client.terminate();
+        for (const upstream of this.upstreams)
+            upstream.terminate();
+        await new Promise((resolve) => this.server.close(() => resolve()));
+    }
+}

package/dist/bridge/native-terminal-control.js

@@ -0,0 +1,271 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
+import xterm from "@xterm/headless";
+const { Terminal } = xterm;
+const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** A screen mirror, never a second input source: only explicit control operations write keys. */
+export class NativeTerminalControl {
+    terminal = new Terminal({ cols: 120, rows: 40, allowProposedApi: true, scrollback: 0, logLevel: "off" });
+    writes = Promise.resolve();
+    lastFrameAt = 0;
+    operation = null;
+    ownedMenu = null;
+    draft = false;
+    inputSequence = "";
+    inputEscapeTimer;
+    pasting = false;
+    options;
+    constructor(options) { this.options = options; }
+    get active() { return this.operation !== null; }
+    feed(text) {
+        this.writes = this.writes.then(() => new Promise((resolve) => this.terminal.write(text, () => {
+            this.lastFrameAt = Date.now();
+            resolve();
+        })));
+    }
+    resize(cols, rows) {
+        this.terminal.resize(Math.max(20, cols), Math.max(8, rows));
+    }
+    localInput(text) {
+        // stdin also carries terminal replies (colors, capabilities, cursor position).
+        // Parse across chunks before deciding that anything came from the keyboard.
+        // The adapter still forwards every original byte to the child PTY unchanged.
+        for (const char of text) {
+            clearTimeout(this.inputEscapeTimer);
+            if (!this.inputSequence) {
+                if (char !== "\u001b") {
+                    this.keyboardInput(char);
+                    continue;
+                }
+                this.inputSequence = char;
+                // A lone Escape is a key; a following introducer belongs to a sequence.
+                this.inputEscapeTimer = setTimeout(() => {
+                    this.inputSequence = "";
+                    this.keyboardInput("\u001b");
+                }, 50);
+                this.inputEscapeTimer.unref?.();
+                continue;
+            }
+            this.inputSequence += char;
+            const sequence = this.inputSequence;
+            if (sequence.length === 2 && "[]P_^XO".includes(char))
+                continue;
+            const kind = sequence[1];
+            if (kind === "[" && !/[@-~]/.test(char))
+                continue;
+            if (kind && "]P_^X".includes(kind) && char !== "\u0007" && !sequence.endsWith("\u001b\\")) {
+                // Bound malformed control strings without treating their payload as text.
+                if (sequence.length > 65_536)
+                    this.inputSequence = sequence.slice(0, 2);
+                continue;
+            }
+            this.inputSequence = "";
+            if (kind && "]P_^X".includes(kind))
+                continue;
+            if (kind === "[") {
+                const body = sequence.slice(2);
+                if (body === "200~" || body === "201~") {
+                    this.pasting = body === "200~";
+                    this.keyboardInput("");
+                    continue;
+                }
+                // Device/status/window reports, Kitty capability replies and focus events.
+                if (/^(?:[?>]?[\d;]*c|\??\d+;\d+R|[\d;]+[nt]|\??[\d;]+\$y|\?[\d;]+u|[IO])$/.test(body))
+                    continue;
+                // Printable keys in Kitty's extended keyboard protocol are still drafts.
+                const key = /^(\d+)(?::[\d:]*)?(?:;([\d:;]+))?u$/.exec(body);
+                if (key) {
+                    const code = Number(key[1]);
+                    const modifiers = key[2]?.split(";")[0] ?? "1";
+                    if (modifiers.endsWith(":3"))
+                        continue; // Key release.
+                    if (code === 13 && modifiers === "1")
+                        this.keyboardInput("\r");
+                    else if (code >= 32 && code < 57344)
+                        this.keyboardInput("x");
+                    else
+                        this.keyboardInput("");
+                }
+                else
+                    this.keyboardInput(""); // Navigation and mouse input cancel controls.
+                continue;
+            }
+            this.keyboardInput(kind === "O" ? "" : char);
+        }
+    }
+    keyboardInput(char) {
+        this.cancel("The local keyboard interrupted the remote control operation.");
+        if (!this.pasting && ["\r", "\n", "\u0003", "\u0015"].includes(char))
+            this.draft = false;
+        else if (char && (char >= " " && char !== "\u007f" || this.pasting))
+            this.draft = true;
+    }
+    cancel(message) {
+        if (this.operation)
+            this.operation.error = new Error(message);
+    }
+    async flush() { await this.writes; }
+    get lines() {
+        const buffer = this.terminal.buffer.active;
+        return Array.from({ length: this.terminal.rows }, (_, row) => buffer.getLine(buffer.viewportY + row)?.translateToString(true) ?? "");
+    }
+    get text() { return this.lines.join("\n"); }
+    check() {
+        const operation = this.operation;
+        if (!operation)
+            throw new Error("No terminal control operation is active.");
+        if (operation.error)
+            throw operation.error;
+        if (operation.identity !== this.options.identity()) {
+            operation.error = new Error("The active CLI session changed during control. Try again.");
+            throw operation.error;
+        }
+        this.options.assertReady();
+        if (Date.now() > operation.deadline)
+            throw new Error("Native CLI control timed out; the result could not be confirmed.");
+    }
+    async run(action) {
+        if (this.operation)
+            throw new Error("Another CLI control operation is in progress.");
+        this.options.assertReady();
+        this.operation = { identity: this.options.identity(), deadline: Date.now() + 25_000 };
+        try {
+            await this.flush();
+            if (this.options.prepare) {
+                await this.options.prepare();
+                this.check();
+                this.draft = false; // The native input state is authoritative when available.
+            }
+            else if (this.draft && this.options.isPromptEmpty?.())
+                this.draft = false;
+            if (this.draft)
+                throw new Error("The local terminal has an input draft. Submit or clear it before using remote controls.");
+            const result = await action();
+            this.check();
+            return result;
+        }
+        finally {
+            const operation = this.operation;
+            let ready = false;
+            try {
+                this.options.assertReady();
+                ready = true;
+            }
+            catch { /* A task or approval may have taken over. */ }
+            // Never send an Escape into a different session or after local input has taken over.
+            if (ready && this.ownedMenu && !operation?.error && operation?.identity === this.options.identity() && this.hasMenu(this.ownedMenu)) {
+                this.options.write("\u001b");
+                await pause(100);
+            }
+            this.ownedMenu = null;
+            this.operation = null;
+        }
+    }
+    async key(text) {
+        this.check();
+        this.options.write(text);
+        await pause(100);
+        await this.flush();
+        this.check();
+    }
+    async waitFor(predicate) {
+        while (true) {
+            this.check();
+            await this.flush();
+            if (predicate())
+                return;
+            await pause(50);
+        }
+    }
+    async command(command) {
+        if (!/^\/[a-z]+$/.test(command))
+            throw new Error("Invalid native control command.");
+        await this.key(`\u001b[200~${command}\u001b[201~`);
+        await this.key("\r");
+        // Claude can consume the first Enter to accept a slash completion while its
+        // interactive UI is finishing startup. Retry only while that exact command
+        // remains at the *last* prompt; never submit an arbitrary draft or a dialog.
+        for (let retry = 0; retry < 3; retry++) {
+            // A lazy-loaded command can briefly leave its autocomplete on screen.
+            // Let the initial render complete before deciding whether Enter was consumed.
+            const until = Date.now() + 1_500;
+            do {
+                await pause(100);
+                await this.flush();
+                this.check();
+            } while (Date.now() < until && Date.now() - this.lastFrameAt < 500);
+            if (Date.now() - this.lastFrameAt < 500)
+                break;
+            const prompt = this.lines.findLast((line) => /^\s*❯/.test(line))?.trim();
+            if (prompt?.replace(/^❯\s*/, "").trim() !== command || /Select model|Select agent|Select variant/.test(this.text))
+                break;
+            await this.key("\r");
+        }
+    }
+    hasMenu(title) {
+        return this.lines.some((line) => line.trim() === title || new RegExp(`^${title}\\s+esc$`, "i").test(line.trim()));
+    }
+    async openMenu(command, title) {
+        if (this.ownedMenu || /Select model|Select agent|Select variant/.test(this.text)) {
+            throw new Error("A native CLI menu is already open. Close it before using remote controls.");
+        }
+        await this.command(command);
+        await this.waitFor(() => this.hasMenu(title));
+        this.ownedMenu = title;
+    }
+    async closeMenu() {
+        const title = this.ownedMenu;
+        if (!title || !this.hasMenu(title))
+            throw new Error("The native selector changed unexpectedly.");
+        await this.key("\u001b");
+        await this.waitFor(() => !this.hasMenu(title));
+        this.ownedMenu = null;
+    }
+    async submitMenu(nextTitle, key = "\r") {
+        const title = this.ownedMenu;
+        if (!title || !this.hasMenu(title))
+            throw new Error("The native selector changed unexpectedly.");
+        await this.key(key);
+        await this.waitFor(() => !this.hasMenu(title));
+        this.ownedMenu = nextTitle && this.hasMenu(nextTitle) ? nextTitle : null;
+    }
+}
+export function parseClaudeModelPicker(text) {
+    const start = text.lastIndexOf("Select model");
+    if (start < 0)
+        return [];
+    return text.slice(start).split("\n").flatMap((line) => {
+        const match = /^\s*([❯>↑↓ ]*)\s*(\d+)\.\s+(.+?)\s*$/.exec(line);
+        if (!match)
+            return [];
+        return [{ index: Number(match[2]), label: match[3].replace(/[✓✔]/g, "").replace(/\s+/g, " ").trim(), current: /[✓✔]/.test(line), focused: /[❯>]/.test(match[1]) }];
+    });
+}
+export function parseClaudeModelSwitchConfirmation(text) {
+    const lines = text.split("\n");
+    const start = lines.findLastIndex((line) => line.trim() === "Switch model?");
+    if (start < 0)
+        return null;
+    const choices = lines.slice(start + 1);
+    const yes = choices.map((line) => /^\s*(❯|>)?\s*1\. Yes, switch to (.+?)\s*$/.exec(line)).find((match) => match);
+    const noIndex = choices.findIndex((line) => /^\s*(?:❯|>)?\s*2\. No, go back\s*$/.test(line));
+    if (!yes || noIndex < 0 || choices.slice(noIndex + 1).some((line) => /^\s*❯/.test(line)))
+        return null;
+    return { model: yes[2], yesFocused: Boolean(yes[1]) };
+}
+export function readClaudePermissionMode(text) {
+    const lines = text.split("\n");
+    const prompt = lines.findLastIndex((line) => /^\s*❯/.test(line));
+    if (prompt < 0 || !/^\s*❯\s*$/.test(lines[prompt]))
+        return null;
+    const footer = lines.slice(prompt + 1).join("\n");
+    for (const [label, mode] of [["plan mode", "plan"], ["accept edits", "acceptEdits"], ["bypass permissions", "bypassPermissions"], ["auto", "auto"], ["don't ask", "dontAsk"]]) {
+        if (footer.includes(`${label} on`))
+            return mode;
+    }
+    return "default";
+}