@unlinearity/cli-wechat-bridge 1.2.0 → 1.2.2

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/language-control.js

@@ -0,0 +1,33 @@
+// 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 { getLocale, parseLocale, setLocale, t } from "../i18n/index.js";
+import { writeJsonFileAtomic } from "../utils/atomic-file.js";
+let languageChangeChain = Promise.resolve();
+/** Language changes never touch turn ownership or pending interactions. */
+export function handleLanguageControl(params) {
+    const run = languageChangeChain.then(() => applyLanguageControl(params));
+    languageChangeChain = run.catch(() => undefined);
+    return run;
+}
+async function applyLanguageControl(params) {
+    if (!params.target)
+        return t("language.current", { locale: getLocale() });
+    const locale = parseLocale(params.target);
+    if (!locale)
+        return t("language.usage");
+    try {
+        writeJsonFileAtomic(params.settingsFile, { locale });
+    }
+    catch (error) {
+        return t("language.saveFailed", { error: error instanceof Error ? error.message : String(error) });
+    }
+    setLocale(locale);
+    process.env.CLI_BRIDGE_LANG = locale;
+    const results = await Promise.allSettled((params.adapters ?? []).map((adapter) => adapter.updateLocale?.(locale) ?? true));
+    const needsRestart = results.some((result) => result.status === "rejected" || result.value === false);
+    return t("language.changed", { locale }) + (needsRestart ? `\n${t("language.companionRestart")}` : "");
+}

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

@@ -5,6 +5,7 @@
 // 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";
+import { t } from "../i18n/index.js";
 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. */
@@ -117,20 +118,20 @@ export class NativeTerminalControl {
     check() {
         const operation = this.operation;
         if (!operation)
-            throw new Error("No terminal control operation is active.");
+            throw new Error(t("native.control.inactive"));
         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.");
+            operation.error = new Error(t("native.control.sessionChanged"));
             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.");
+            throw new Error(t("native.control.timeout"));
     }
     async run(action) {
         if (this.operation)
-            throw new Error("Another CLI control operation is in progress.");
+            throw new Error(t("native.control.busy"));
         this.options.assertReady();
         this.operation = { identity: this.options.identity(), deadline: Date.now() + 25_000 };
         try {
@@ -143,7 +144,7 @@ export class NativeTerminalControl {
             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.");
+                throw new Error(t("native.control.draft"));
             const result = await action();
             this.check();
             return result;
@@ -183,7 +184,7 @@ export class NativeTerminalControl {
     }
     async command(command) {
         if (!/^\/[a-z]+$/.test(command))
-            throw new Error("Invalid native control command.");
+            throw new Error(t("native.control.invalid"));
         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
@@ -211,7 +212,7 @@ export class NativeTerminalControl {
     }
     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.");
+            throw new Error(t("native.control.menuOpen"));
         }
         await this.command(command);
         await this.waitFor(() => this.hasMenu(title));
@@ -220,7 +221,7 @@ export class NativeTerminalControl {
     async closeMenu() {
         const title = this.ownedMenu;
         if (!title || !this.hasMenu(title))
-            throw new Error("The native selector changed unexpectedly.");
+            throw new Error(t("native.control.selectorChanged"));
         await this.key("\u001b");
         await this.waitFor(() => !this.hasMenu(title));
         this.ownedMenu = null;
@@ -228,7 +229,7 @@ export class NativeTerminalControl {
     async submitMenu(nextTitle, key = "\r") {
         const title = this.ownedMenu;
         if (!title || !this.hasMenu(title))
-            throw new Error("The native selector changed unexpectedly.");
+            throw new Error(t("native.control.selectorChanged"));
         await this.key(key);
         await this.waitFor(() => !this.hasMenu(title));
         this.ownedMenu = nextTitle && this.hasMenu(nextTitle) ? nextTitle : null;
@@ -245,10 +246,22 @@ export function parseClaudeModelPicker(text) {
         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]))
+    if (prompt < 0 || !isClaudePromptVisuallyEmpty(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"]]) {
@@ -257,3 +270,18 @@ export function readClaudePermissionMode(text) {
     }
     return "default";
 }
+/**
+ * Claude renders idle decorations inside the input box: an automatic context
+ * chip like `[⧉ In file.ts]` and a suggestion placeholder like
+ * Try "how does <filepath> work?". Both appear on a freshly started session
+ * before any user input; neither is a draft. Real typed input still fails
+ * this check (and the local-input mirror blocks controls independently).
+ */
+function isClaudePromptVisuallyEmpty(line) {
+    const body = line
+        .replace(/^\s*❯\s*/, "")
+        .replace(/^\[⧉ [^\]]*\]\s*/, "")
+        .replace(/^Try "[^"]*"\s*$/, "")
+        .replace(/\s+$/, "");
+    return body.length === 0;
+}