cli-wechat-bridge 1.1.6 → 1.1.8

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

@@ -0,0 +1,133 @@
+import { NativeTerminalControl, parseClaudeModelPicker, 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(() => 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/native-terminal-control.js

@@ -0,0 +1,253 @@
+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 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";
+}