@unlinearity/cli-wechat-bridge 1.2.1 → 1.2.2

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;
@@ -260,7 +261,7 @@ export function parseClaudeModelSwitchConfirmation(text) {
 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"]]) {
@@ -269,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;
+}

package/dist/bridge/opencode-v2-compat.js

@@ -110,9 +110,14 @@ function normalizeFormQuestions(form) {
     });
 }
 function normalizeFormAnswer(field, values) {
+    const options = Array.isArray(field.options) ? field.options.filter(isRecord) : [];
+    const normalizedValues = values.map((value) => {
+        const option = options.find((option) => option.label === value);
+        return typeof option?.value === "string" ? option.value : value;
+    });
     if (field.type === "multiselect")
-        return values;
-    const value = values[0] ?? "";
+        return normalizedValues;
+    const value = normalizedValues[0] ?? "";
     if (field.type === "boolean") {
         return /^(1|true|yes|y)$/i.test(String(value));
     }
@@ -407,7 +412,10 @@ export async function createOpenCodeV2CompatClient(options) {
                 sessionID: input.sessionID ?? permissionSessions.get(String(input.requestID)),
                 requestID: input.requestID,
                 decision: input.reply === "reject" ? "reject" : input.reply,
-            }, requestOptions).finally(() => permissionSessions.delete(String(input.requestID)))),
+            }, requestOptions).then((response) => {
+                permissionSessions.delete(String(input.requestID));
+                return response;
+            })),
         },
         question: {
             reply: (input, requestOptions) => result(async () => {

package/dist/bridge/wechat-bridge.js

@@ -22,6 +22,8 @@ import { canDrainDeferredCodexInboundQueue, formatDeferredCodexInboundQueueMessa
 import { TurnCoordinator } from "../core/turn-coordinator.js";
 import { resolveOutboundConversationTarget } from "../core/outbound-target.js";
 import { handleAdapterControl } from "./adapter-control.js";
+import { handleLanguageControl } from "./language-control.js";
+import { LANGUAGE_FILE } from "../wechat/channel-config.js";
 import { forwardBridgeEvent } from "../core/bridge-event-forwarder.js";
 import { isDirectModuleRun } from "../core/direct-run.js";
 import { WechatChannelPort } from "../channels/wechat/wechat-channel-port.js";
@@ -706,7 +708,7 @@ async function main() {
                                     task: nextActiveTask,
                                     conversation: channelMessage.conversation,
                                     onBusy: async () => {
-                                        await queueInboundReply(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);
+                                        await queueInboundReply(message.senderId, t("bridge.busy.remote", { adapter: options.adapter }));
                                     },
                                     forward: async () => {
                                         await dispatchInboundWechatText({
@@ -752,7 +754,7 @@ async function main() {
                     if (chatType === "direct") {
                         const result = await channelDriver.sendText({
                             target: channelDriver.directConversation(senderId),
-                            text: "Unauthorized.",
+                            text: t("channel.unauthorized"),
                             context: "notice",
                             log: (entry) => stateStore.appendLog(entry),
                         });
@@ -884,7 +886,7 @@ async function main() {
                             const result = await turns.dispatch({
                                 task: nextActiveTask,
                                 onBusy: async () => {
-                                    await queueWechatMessage(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);
+                                    await queueWechatMessage(message.senderId, t("bridge.busy.remote", { adapter: options.adapter }));
                                 },
                                 forward: async () => {
                                     await dispatchInboundWechatText({
@@ -954,7 +956,7 @@ function syncSharedSessionState(stateStore, adapter) {
         }
     }
 }
-function wireAdapterEvents(params) {
+export function wireAdapterEvents(params) {
     const { adapter, channelDriver, resumeCoordinator, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, getActiveTask, clearActiveTask, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, wecomTransport, getWecomTarget, } = params;
     const channelPort = options.channelId === "wecom"
         ? new WecomChannelPort({
@@ -984,10 +986,12 @@ function wireAdapterEvents(params) {
         syncLocalClientEndpoint();
         const adapterState = adapter.getState();
         const bridgeState = stateStore.getState();
-        if (bridgeState.pendingConfirmation && !adapterState.pendingApproval) {
+        if (bridgeState.pendingConfirmation && (!adapterState.pendingApproval
+            || (adapterState.pendingApprovals !== undefined && bridgeState.pendingConfirmation.requestId !== adapterState.pendingApproval.requestId))) {
             stateStore.clearPendingConfirmation();
         }
-        if (bridgeState.pendingUserInput && !adapterState.pendingUserInput) {
+        if (bridgeState.pendingUserInput && (!adapterState.pendingUserInput
+            || (bridgeState.pendingUserInput.requestId !== undefined && bridgeState.pendingUserInput.requestId !== adapterState.pendingUserInput.requestId))) {
             stateStore.clearPendingUserInput();
         }
         const authorizedUserId = stateStore.getState().authorizedUserId;
@@ -1050,14 +1054,21 @@ function wireAdapterEvents(params) {
             },
             approvalRequired: (next) => {
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
+                    const liveState = adapter.getState();
+                    if (liveState.pendingApprovals !== undefined && liveState.pendingApproval?.requestId !== next.request.requestId)
+                        return;
                     const pending = toPendingApproval(next.request);
-                    stateStore.setPendingConfirmation(pending);
                     stateStore.appendLog(`Approval requested (${pending.source}): ${pending.commandPreview}`);
-                    await queueWechatMessage(authorizedUserId, formatApprovalMessage(pending, adapterState), "approval_required", eventTarget);
+                    await queueWechatMessage(authorizedUserId, formatApprovalMessage(pending, liveState), "approval_required", eventTarget);
+                    if (adapter.getState().pendingApproval?.requestId === pending.requestId) {
+                        stateStore.setPendingConfirmation(pending);
+                    }
                 }));
             },
             userInputRequired: (next) => {
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
+                    if (next.request.requestId !== undefined && adapter.getState().pendingUserInput?.requestId !== next.request.requestId)
+                        return;
                     const pending = toPendingUserInput(next.request);
                     stateStore.setPendingUserInput(pending);
                     stateStore.appendLog(`User input requested: questions=${pending.questions.length}`);
@@ -1155,12 +1166,12 @@ function formatInboundMessagePreview(message) {
     }
     return "(empty)";
 }
-async function handleInboundMessage(params) {
+export async function handleInboundMessage(params) {
     const { message, channelMessage, channelDriver, } = params;
     const { options, stateStore, adapter, resumeCoordinator, queueWechatMessage, outputBatcher, clearActiveTask, dispatchInboundText, deferInboundMessage, } = params;
     const state = stateStore.getState();
     if (message.senderId !== state.authorizedUserId) {
-        await queueWechatMessage(message.senderId, `Unauthorized. This bridge only accepts messages from ${channelDriver.operatorDescription}.`);
+        await queueWechatMessage(message.senderId, t("bridge.unauthorized", { mode: t("bridge.mode.bridge"), operator: channelDriver.operatorDescription }));
         return null;
     }
     const systemCommand = parseWechatControlCommand(message.text, {
@@ -1169,19 +1180,24 @@ async function handleInboundMessage(params) {
         hasPendingUserInput: Boolean(state.pendingUserInput),
     });
     switch (systemCommand?.type) {
+        case "language":
+            await queueWechatMessage(message.senderId, await handleLanguageControl({
+                target: systemCommand.target, settingsFile: params.localeSettingsFile ?? LANGUAGE_FILE, adapters: [adapter],
+            }));
+            return null;
         case "model":
         case "plan":
             await queueWechatMessage(message.senderId, await handleAdapterControl(adapter, message.senderId, systemCommand));
             return null;
         case "broadcast":
-            await queueWechatMessage(message.senderId, "/all is only available in daemon mode. Start the daemon with wechat-daemon or wecom-daemon to broadcast to all workers.");
+            await queueWechatMessage(message.senderId, t("bridge.broadcast.daemonOnly"));
             return null;
         case "status":
             await queueWechatMessage(message.senderId, formatStatusReport(stateStore.getState(), adapter.getState()));
             return null;
         case "resume": {
             if (!isWechatResumeEnabled(options.adapter)) {
-                await queueWechatMessage(message.senderId, `${channelDriver.displayName} /resume is disabled in ${options.adapter} mode. Use /resume directly inside "${channelDriver.id}-${options.adapter}"; the remote channel will follow the active local session.`);
+                await queueWechatMessage(message.senderId, t("bridge.resume.disabled", { channel: channelDriver.displayName, adapter: options.adapter, command: `${channelDriver.id}-${options.adapter}` }));
                 return null;
             }
             try {
@@ -1201,7 +1217,7 @@ async function handleInboundMessage(params) {
         }
         case "new_session": {
             if (!adapter.createSession) {
-                await queueWechatMessage(message.senderId, `/new is not available in ${options.adapter} mode.`);
+                await queueWechatMessage(message.senderId, t("bridge.newSession.unavailable", { adapter: options.adapter }));
                 return null;
             }
             await outputBatcher.flushNow();
@@ -1217,8 +1233,8 @@ async function handleInboundMessage(params) {
         case "stop": {
             const interrupted = await adapter.interrupt();
             await queueWechatMessage(message.senderId, interrupted
-                ? "Interrupt signal sent to the active worker."
-                : "No running worker was available to interrupt.");
+                ? t("bridge.interrupt.workerSent")
+                : t("bridge.interrupt.workerIdle"));
             return null;
         }
         case "reset":
@@ -1230,47 +1246,48 @@ async function handleInboundMessage(params) {
             resumeCoordinator.clear();
             await adapter.reset();
             stateStore.appendLog("Worker reset by owner.");
-            await queueWechatMessage(message.senderId, "Worker session has been reset.");
+            await queueWechatMessage(message.senderId, t("bridge.reset.done"));
             return null;
         case "confirm": {
             const pending = state.pendingConfirmation;
             if (!pending) {
-                await queueWechatMessage(message.senderId, "No pending approval request.");
+                await queueWechatMessage(message.senderId, t("approval.noPending"));
                 return null;
             }
-            const confirmed = await adapter.resolveApproval("confirm");
+            const confirmed = await adapter.resolveApproval("confirm", pending.requestId);
             if (!confirmed) {
-                await queueWechatMessage(message.senderId, "The worker could not apply this approval request.");
+                await queueWechatMessage(message.senderId, t("bridge.approval.applyFailed"));
                 return null;
             }
-            stateStore.clearPendingConfirmation();
+            if (stateStore.getState().pendingConfirmation?.requestId === pending.requestId) {
+                stateStore.clearPendingConfirmation();
+            }
             stateStore.appendLog(`Approval confirmed: ${pending.commandPreview}`);
-            await queueWechatMessage(message.senderId, "Approval confirmed. Continuing...");
-            return {
-                startedAt: Date.now(),
-                inputPreview: pending.commandPreview,
-            };
+            await queueWechatMessage(message.senderId, t("approval.confirmed"));
+            return null;
         }
         case "deny": {
             const pending = state.pendingConfirmation;
             if (!pending) {
-                await queueWechatMessage(message.senderId, "No pending approval request.");
+                await queueWechatMessage(message.senderId, t("approval.noPending"));
                 return null;
             }
-            const denied = await adapter.resolveApproval("deny");
+            const denied = await adapter.resolveApproval("deny", pending.requestId);
             if (!denied) {
-                await queueWechatMessage(message.senderId, "The worker could not deny this approval request cleanly.");
+                await queueWechatMessage(message.senderId, t("bridge.approval.denyFailed"));
                 return null;
             }
-            stateStore.clearPendingConfirmation();
+            if (stateStore.getState().pendingConfirmation?.requestId === pending.requestId) {
+                stateStore.clearPendingConfirmation();
+            }
             stateStore.appendLog(`Approval denied: ${pending.commandPreview}`);
-            await queueWechatMessage(message.senderId, "Approval denied.");
+            await queueWechatMessage(message.senderId, t("approval.denied"));
             return null;
         }
         case "answer": {
             const pending = state.pendingUserInput;
             if (!pending) {
-                await queueWechatMessage(message.senderId, "No pending user input request.");
+                await queueWechatMessage(message.senderId, t("bridge.answer.none"));
                 return null;
             }
             const parsed = parsePendingUserInputAnswerCommand(systemCommand.raw, pending);
@@ -1278,18 +1295,16 @@ async function handleInboundMessage(params) {
                 await queueWechatMessage(message.senderId, parsed.error);
                 return null;
             }
-            const submitted = await adapter.submitUserInput(parsed.answers);
+            const submitted = await adapter.submitUserInput(parsed.answers, pending.requestId);
             if (!submitted) {
-                await queueWechatMessage(message.senderId, "The worker could not apply this answer.");
+                await queueWechatMessage(message.senderId, t("bridge.answer.failed"));
                 return null;
             }
-            stateStore.clearPendingUserInput();
+            if (stateStore.getState().pendingUserInput?.requestId === pending.requestId)
+                stateStore.clearPendingUserInput();
             stateStore.appendLog(`User input answered: ${parsed.preview}`);
-            await queueWechatMessage(message.senderId, "Answer submitted. Continuing...");
-            return {
-                startedAt: Date.now(),
-                inputPreview: parsed.preview,
-            };
+            await queueWechatMessage(message.senderId, t("bridge.answer.sent"));
+            return null;
         }
     }
     const adapterState = adapter.getState();
@@ -1316,16 +1331,16 @@ async function handleInboundMessage(params) {
             const pendingUserInput = stateStore.getState().pendingUserInput;
             await queueWechatMessage(message.senderId, pendingUserInput
                 ? formatPendingUserInputReminder(pendingUserInput)
-                : `${options.adapter} is waiting for structured input. Reply with /answer <key>=<value> ...`);
+                : t("bridge.input.waiting", { adapter: options.adapter }));
         },
         remindBusy: async () => {
             const currentState = adapter.getState();
             if ((options.adapter === "codex" || options.adapter === "opencode" || options.adapter === "pi") &&
                 currentState.activeTurnOrigin === "local") {
-                await queueWechatMessage(message.senderId, `${options.adapter === "opencode" ? "OpenCode" : options.adapter === "pi" ? "Pi" : "codex"} is currently busy with a local terminal turn. Wait for it to finish or use /stop.`);
+                await queueWechatMessage(message.senderId, t("bridge.busy.local", { adapter: options.adapter === "opencode" ? "OpenCode" : options.adapter === "pi" ? "Pi" : "codex" }));
                 return;
             }
-            await queueWechatMessage(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);
+            await queueWechatMessage(message.senderId, t("bridge.busy.remote", { adapter: options.adapter }));
         },
         defer: async () => {
             await deferInboundMessage(message);

package/dist/channels/channel-driver-factory.js

@@ -0,0 +1,44 @@
+import { WecomChannelDriver } from "./wecom/wecom-driver.js";
+import { WechatChannelDriver } from "./wechat/wechat-driver.js";
+import { LocalChannelDriver } from "./local/local-driver.js";
+/**
+ * Single construction point for channel drivers. Adding a channel means
+ * adding a driver implementation and one branch here; orchestration layers
+ * stay channel-neutral.
+ */
+export function createChannelDriver(input) {
+    if (input.channelId === "wecom") {
+        if (!input.wecomTransport) {
+            throw new Error("The wecom channel requires a WeCom transport.");
+        }
+        return new WecomChannelDriver({
+            transport: input.wecomTransport,
+            accountId: input.accountId,
+            operatorId: input.authorizedUserId,
+            logError: input.logError,
+        });
+    }
+    if (input.channelId === "local") {
+        const files = input.localFiles ?? {
+            inboxFile: "",
+            transcriptFile: "",
+        };
+        if (!files.inboxFile || !files.transcriptFile) {
+            throw new Error("The local channel requires inbox and transcript file paths.");
+        }
+        return new LocalChannelDriver({
+            operatorId: input.authorizedUserId,
+            inboxFile: files.inboxFile,
+            transcriptFile: files.transcriptFile,
+            log: input.log,
+        });
+    }
+    if (!input.wechatTransport) {
+        throw new Error("The wechat channel requires a WeChat transport.");
+    }
+    return new WechatChannelDriver({
+        transport: input.wechatTransport,
+        logError: input.logError,
+        buildInboundPrompt: input.buildWechatInboundPrompt,
+    });
+}

package/dist/channels/local/local-channel-port.js

@@ -0,0 +1,40 @@
+/**
+ * Channel boundary for local loopback output. Unlike WeChat there is no
+ * plain-text conversion: the harness consumes the raw final reply.
+ */
+export class LocalChannelPort {
+    channelId = "local";
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async send(output) {
+        if (output.target.channelId !== "local") {
+            throw new Error(`Local channel cannot send to ${output.target.channelId}.`);
+        }
+        const recipientId = output.target.recipientId;
+        const prefixText = (text) => this.deps.prefixText?.(output.adapter, text) ?? text;
+        const context = typeof output.metadata?.sendContext === "string"
+            ? output.metadata.sendContext
+            : output.kind;
+        if (output.kind === "final_reply") {
+            const rawText = output.text ?? "";
+            if (!rawText.trim()) {
+                this.deps.onEmptyVisibleReply?.(output.adapter, rawText);
+                return true;
+            }
+            const sent = await this.deps.sendText(recipientId, prefixText(rawText), "final_reply");
+            if (sent) {
+                this.deps.onTextSent?.(output.adapter, rawText);
+            }
+            return true;
+        }
+        if (output.attachment) {
+            await this.deps.sendAttachment?.(recipientId, output.attachment);
+        }
+        if (output.text?.trim()) {
+            return Boolean(await this.deps.sendText(recipientId, prefixText(output.text), context));
+        }
+        return true;
+    }
+}