@unlinearity/cli-wechat-bridge 1.2.0 → 1.2.2

package/dist/companion/local-companion.js

@@ -7,6 +7,7 @@
 // LICENSE.txt. Network services built on it must offer source to users.
 import net from "node:net";
 import path from "node:path";
+import { parseLocale, setLocale, t } from "../i18n/index.js";
 import { createBridgeAdapter } from "../bridge/bridge-adapters.js";
 import { LOCAL_COMPANION_RECONNECT_GRACE_MS, } from "../bridge/bridge-adapters.shared.js";
 import { runCodexRemoteClientFromEndpoint } from "./codex-remote-client.js";
@@ -170,7 +171,7 @@ export async function runLocalCompanion(options) {
         }
         sendLocalCompanionMessage(activeSocket, {
             type: "state",
-            state: adapter.getState(),
+            state: { ...adapter.getState(), supportsLocaleUpdates: true },
         });
     };
     const sendResponse = (socket, id, ok, result, error) => {
@@ -211,6 +212,15 @@ export async function runLocalCompanion(options) {
     const handleBridgeRequest = async (socket, message) => {
         try {
             switch (message.payload.command) {
+                case "set_locale": {
+                    const locale = parseLocale(message.payload.locale);
+                    if (!locale)
+                        throw new Error(t("language.usage"));
+                    setLocale(locale);
+                    process.env.CLI_BRIDGE_LANG = locale;
+                    sendResponse(socket, message.id, true);
+                    break;
+                }
                 case "send_input":
                     await adapter.sendInput(message.payload.text);
                     sendResponse(socket, message.id, true);
@@ -239,18 +249,18 @@ export async function runLocalCompanion(options) {
                     break;
                 case "list_models":
                     if (!adapter.listModels)
-                        throw new Error("Model listing is not supported by this companion.");
+                        throw new Error(t("companion.modelsUnsupported"));
                     sendResponse(socket, message.id, true, await adapter.listModels());
                     break;
                 case "select_model":
                     if (!adapter.selectModel)
-                        throw new Error("Model selection is not supported by this companion.");
+                        throw new Error(t("companion.modelUnsupported"));
                     sendResponse(socket, message.id, true, await adapter.selectModel(message.payload.modelId));
                     publishState();
                     break;
                 case "set_plan_mode":
                     if (!adapter.setPlanMode)
-                        throw new Error("Plan mode is not supported by this companion.");
+                        throw new Error(t("companion.planUnsupported"));
                     sendResponse(socket, message.id, true, await adapter.setPlanMode(message.payload.enabled));
                     publishState();
                     break;
@@ -263,10 +273,14 @@ export async function runLocalCompanion(options) {
                     sendResponse(socket, message.id, true);
                     break;
                 case "resolve_approval":
-                    sendResponse(socket, message.id, true, await adapter.resolveApproval(message.payload.action));
+                    sendResponse(socket, message.id, true, message.payload.requestId === undefined
+                        ? false
+                        : await adapter.resolveApproval(message.payload.action, message.payload.requestId));
                     break;
                 case "submit_user_input":
-                    sendResponse(socket, message.id, true, await adapter.submitUserInput(message.payload.answers));
+                    sendResponse(socket, message.id, true, adapter.getState().supportsUserInputRequestIds && !message.payload.requestId
+                        ? false
+                        : await adapter.submitUserInput(message.payload.answers, message.payload.requestId));
                     break;
                 case "dispose":
                     sendResponse(socket, message.id, true);
@@ -308,6 +322,11 @@ export async function runLocalCompanion(options) {
                 localDetach = attachLocalCompanionMessageListener(socket, (message) => {
                     if (!helloAcknowledged) {
                         if (message.type === "hello_ack") {
+                            const locale = parseLocale(message.locale);
+                            if (locale) {
+                                setLocale(locale);
+                                process.env.CLI_BRIDGE_LANG = locale;
+                            }
                             helloAcknowledged = true;
                             closeReason = null;
                             activeSocket = socket;
@@ -356,6 +375,7 @@ export async function runLocalCompanion(options) {
                     type: "hello",
                     token: endpoint.token,
                     companionPid: process.pid,
+                    supportsLocaleUpdates: true,
                 });
             });
             socket.once("error", (error) => {
@@ -402,13 +422,13 @@ export async function runLocalCompanion(options) {
         }
     };
     adapter.setEventSink((event) => {
+        publishState();
         if (activeSocket) {
             sendLocalCompanionMessage(activeSocket, {
                 type: "event",
                 event,
             });
         }
-        publishState();
         if (event.type === "fatal_error") {
             void closeCompanion(1, "fatal_error");
             return;

package/dist/companion/opencode-v2-tui-bridge-plugin.js

@@ -0,0 +1,93 @@
+// 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 net from "node:net";
+const ROUTE_POLL_INTERVAL_MS = 100;
+const MAX_BUFFER_SIZE = 1024 * 1024;
+export default {
+    id: "cli-wechat-bridge.session-route-v2",
+    setup(context) {
+        const port = Number(context.options.port);
+        const token = typeof context.options.token === "string" ? context.options.token : "";
+        if (!Number.isInteger(port) || port <= 0 || !token) {
+            return () => undefined;
+        }
+        const socket = net.connect({ host: "127.0.0.1", port });
+        let connected = false;
+        let inputBuffer = "";
+        let lastSessionId;
+        let queuedFrame = null;
+        const writeFrame = (frame) => {
+            if (socket.destroyed)
+                return;
+            if (!connected) {
+                queuedFrame = frame;
+                return;
+            }
+            socket.write(`${JSON.stringify(frame)}\n`);
+        };
+        const publishRoute = () => {
+            const route = context.ui.router.current();
+            const sessionId = route.type === "session" && typeof route.sessionID === "string"
+                ? route.sessionID
+                : null;
+            if (sessionId === lastSessionId)
+                return;
+            lastSessionId = sessionId;
+            writeFrame({
+                type: "route_state",
+                sessionId,
+                observedAt: new Date().toISOString(),
+            });
+        };
+        socket.setEncoding("utf8");
+        socket.on("connect", () => {
+            socket.setNoDelay(true);
+            socket.write(`${JSON.stringify({ type: "hello", token })}\n`);
+            connected = true;
+            publishRoute();
+            if (queuedFrame) {
+                socket.write(`${JSON.stringify(queuedFrame)}\n`);
+                queuedFrame = null;
+            }
+        });
+        socket.on("data", (chunk) => {
+            inputBuffer += chunk;
+            if (inputBuffer.length > MAX_BUFFER_SIZE) {
+                socket.destroy();
+                return;
+            }
+            for (;;) {
+                const newline = inputBuffer.indexOf("\n");
+                if (newline < 0)
+                    break;
+                const line = inputBuffer.slice(0, newline).trim();
+                inputBuffer = inputBuffer.slice(newline + 1);
+                if (!line)
+                    continue;
+                try {
+                    const frame = JSON.parse(line);
+                    if (frame.type === "select_session" && typeof frame.sessionId === "string") {
+                        context.ui.router.navigate({ type: "session", sessionID: frame.sessionId });
+                        publishRoute();
+                    }
+                }
+                catch {
+                    // Ignore malformed bridge frames and keep the visible TUI alive.
+                }
+            }
+        });
+        socket.on("error", () => {
+            // Keep the native TUI usable if the bridge-side observer disappears.
+        });
+        const timer = setInterval(publishRoute, ROUTE_POLL_INTERVAL_MS);
+        timer.unref?.();
+        return () => {
+            clearInterval(timer);
+            socket.destroy();
+        };
+    },
+};

package/dist/companion/pi-tui-bridge-extension.js

@@ -330,11 +330,14 @@ export default function piTuiBridgeExtension(pi) {
     });
     pi.on("message_end", (event, context) => {
         latestContext = context;
+        const message = isRecord(event.message) ? event.message : {};
+        if (message.role !== "assistant") {
+            return;
+        }
         const text = extractAssistantText(event.message);
-        if (!text) {
+        if (!text && message.stopReason !== "error") {
             return;
         }
-        const message = isRecord(event.message) ? event.message : {};
         writeFrame({
             type: "assistant_message",
             text,
@@ -346,9 +349,12 @@ export default function piTuiBridgeExtension(pi) {
         latestContext = context;
         writeFrame({ type: "agent_start" });
     });
-    pi.on("agent_settled", (_event, context) => {
+    pi.on("agent_settled", (event, context) => {
         latestContext = context;
         writeSessionState(context, "settled");
-        writeFrame({ type: "agent_settled" });
+        writeFrame({
+            type: "agent_settled",
+            ...(typeof event.aborted === "boolean" ? { aborted: event.aborted } : {}),
+        });
     });
 }

package/dist/core/bridge-control.js

@@ -7,6 +7,9 @@ export function parseBridgeControlCommand(text) {
     const command = rawCommand.toLowerCase();
     const argument = rest.join(" ").trim();
     switch (command) {
+        case "/lang":
+        case "/language":
+            return { type: "language", target: argument || undefined };
         case "/status":
             return { type: "status" };
         case "/resume":

package/dist/core/bridge-defer.js

@@ -1,3 +1,4 @@
+import { t } from "../i18n/index.js";
 export function shouldDeferCodexInboundMessage(params) {
     return (params.adapter === "codex" &&
         !params.hasPendingConfirmation &&
@@ -18,8 +19,8 @@ export function canDrainDeferredCodexInboundQueue(params) {
         params.status !== "awaiting_input");
 }
 export function formatDeferredCodexInboundQueueMessage(queuePosition) {
-    return `Queued for delivery after the current local Codex turn finishes. Queue position: ${queuePosition}.`;
+    return t("bridge.deferred", { position: queuePosition });
 }
 export function isRetryableDeferredCodexDrainError(errorText) {
-    return /still working|approval request is pending|waiting for local terminal input/i.test(errorText);
+    return /still working|approval request is pending|waiting for local terminal input|仍在运行|有待审批请求|正在等待本地终端输入/i.test(errorText);
 }

package/dist/core/bridge-event-forwarder.js

@@ -19,6 +19,9 @@ export async function forwardBridgeEvent(event, handlers) {
         case "thinking":
             await handlers.thinking?.(event);
             return;
+        case "approval_state_changed":
+            await handlers.approvalStateChanged?.(event);
+            return;
         case "approval_required":
             await handlers.approvalRequired?.(event);
             return;

package/dist/core/channel-types.js

@@ -1,3 +1,7 @@
 export function normalizeBridgeChannelId(value) {
-    return value === "wecom" ? "wecom" : "wechat";
+    if (value === "wecom")
+        return "wecom";
+    if (value === "local")
+        return "local";
+    return "wechat";
 }