@unlinearity/cli-wechat-bridge 1.1.5 → 1.2.0

package/dist/bridge/bridge-utils.js

@@ -1,9 +1,15 @@
+// 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";
-const ANSI_ESCAPE_RE = 
-// eslint-disable-next-line no-control-regex
-/\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+import { parseBridgeControlCommand, } from "../core/bridge-control.js";
+import { normalizeOutput, summarizeOutput, truncatePreview, } from "../core/text-utils.js";
+export { buildInstanceId, buildOneTimeCode, formatDuration, normalizeOutput, nowIso, stripAnsi, summarizeOutput, truncatePreview, } from "../core/text-utils.js";
 // Messages older than bridge start minus this grace window are treated as
 // pre-start backlog and skipped. The window must absorb realistic clock skew
 // between the local machine and WeChat server timestamps: with a small value,
@@ -99,29 +105,6 @@ const INLINE_REFERENCE_ONLY_FILE_EXTENSIONS = new Set([
 const INLINE_MAAS_URL_RE = /https?:\/\/[^\s]*?\/([A-Za-z]:\\.+?(?:\.\s*[A-Za-z0-9]{2,8})+)(?:\?[^\n]*)?/g;
 const INLINE_WINDOWS_PATH_RE = /(^|[^\w])`?([A-Za-z]:\\(?:[^\\/:*?"<>|\r\n`]+\\)*[^\\/:*?"<>|\r\n`]+?(?:\.\s*[A-Za-z0-9]{2,8})+)`?(?=$|[^\w])/gm;
 const INLINE_HOME_RELATIVE_PATH_RE = /(^|[^\w])`?((?:~[\\/])?(?:Desktop|Documents|Downloads|Pictures|Videos|Music)[\\/](?:[^\\/:*?"<>|\r\n`]+[\\/])*[^\\/:*?"<>|\r\n`]+?(?:\.\s*[A-Za-z0-9]{2,8})+)`?(?=$|[^\w])/gim;
-export function nowIso() {
-    return new Date().toISOString();
-}
-export function stripAnsi(text) {
-    return text.replace(ANSI_ESCAPE_RE, "");
-}
-export function normalizeOutput(text) {
-    return stripAnsi(text)
-        // eslint-disable-next-line no-control-regex
-        .replace(/\u0000/g, "")
-        .replace(/\r\n/g, "\n")
-        .replace(/\r/g, "\n");
-}
-export function truncatePreview(text, maxLength = 140) {
-    const normalized = normalizeOutput(text).trim().replace(/\s+/g, " ");
-    if (!normalized) {
-        return "(empty)";
-    }
-    if (normalized.length <= maxLength) {
-        return normalized;
-    }
-    return `${normalized.slice(0, Math.max(0, maxLength - 3))}...`;
-}
 export function isThinkingForwardEnabled() {
     if (process.env.CLI_BRIDGE_THINKING_FORWARD === "1") {
         return true;
@@ -150,51 +133,8 @@ export function formatThinkingForWechat(text, maxLength = 500) {
     }
     return `${normalized.slice(0, Math.max(0, maxLength - 3))}...`;
 }
-export function buildOneTimeCode(length = 6) {
-    const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
-    let code = "";
-    while (code.length < length) {
-        code += alphabet[Math.floor(Math.random() * alphabet.length)];
-    }
-    return code;
-}
-export function buildInstanceId() {
-    return `bridge-${Date.now().toString(36)}-${buildOneTimeCode(6).toLowerCase()}`;
-}
 export function parseSystemCommand(text) {
-    const trimmed = text.trim();
-    if (!trimmed.startsWith("/")) {
-        return null;
-    }
-    const [rawCommand, ...rest] = trimmed.split(/\s+/);
-    if (!rawCommand) {
-        return null;
-    }
-    const command = rawCommand.toLowerCase();
-    const argument = rest.join(" ").trim();
-    switch (command) {
-        case "/status":
-            return { type: "status" };
-        case "/resume":
-            return argument ? { type: "resume", target: argument } : { type: "resume" };
-        case "/new":
-        case "/new-session":
-            return { type: "new_session" };
-        case "/stop":
-            return { type: "stop" };
-        case "/reset":
-            return { type: "reset" };
-        case "/confirm":
-        case "/yes":
-            return { type: "confirm" };
-        case "/deny":
-        case "/no":
-            return { type: "deny" };
-        case "/answer":
-            return argument ? { type: "answer", raw: argument } : null;
-        default:
-            return null;
-    }
+    return parseBridgeControlCommand(text);
 }
 export function parseWechatControlCommand(text, options) {
     const systemCommand = parseSystemCommand(text);
@@ -474,32 +414,6 @@ export function detectCliApproval(text) {
         denyInput: matched.denyInput,
     };
 }
-export function formatDuration(durationMs) {
-    if (!Number.isFinite(durationMs) || durationMs < 0) {
-        return "0s";
-    }
-    const totalSeconds = Math.floor(durationMs / 1000);
-    const minutes = Math.floor(totalSeconds / 60);
-    const seconds = totalSeconds % 60;
-    if (!minutes) {
-        return `${seconds}s`;
-    }
-    return `${minutes}m ${seconds}s`;
-}
-export function summarizeOutput(text, maxLength = 280) {
-    const normalized = normalizeOutput(text)
-        .split("\n")
-        .map((line) => line.trim())
-        .filter(Boolean);
-    if (!normalized.length) {
-        return "(no output)";
-    }
-    const summary = normalized.slice(-6).join("\n");
-    if (summary.length <= maxLength) {
-        return summary;
-    }
-    return summary.slice(summary.length - maxLength);
-}
 export function formatStatusReport(bridgeState, adapterState) {
     const pending = bridgeState.pendingConfirmation;
     const pendingUserInput = bridgeState.pendingUserInput;
@@ -1205,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,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,259 @@
+// 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 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";
+}