@unlinearity/cli-wechat-bridge 1.2.0 → 1.2.2

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;
+    }
+}

package/dist/channels/local/local-driver.js

@@ -0,0 +1,217 @@
+// 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 { t } from "../../i18n/index.js";
+import fs from "node:fs";
+import path from "node:path";
+import { getWorkspaceChannelPaths } from "../../wechat/channel-config.js";
+/**
+ * Loopback channel for local end-to-end runs. Inbound messages are JSONL
+ * lines appended to the inbox file; every outbound text is appended to the
+ * transcript file so an external harness can drive and observe the full
+ * bridge pipeline without a remote messaging platform.
+ */
+export const LOCAL_CHANNEL_OPERATOR_ID = "local-operator";
+export function getLocalChannelFiles(cwd) {
+    const workspaceDir = getWorkspaceChannelPaths(cwd).workspaceDir;
+    return {
+        inboxFile: path.join(workspaceDir, "local-inbox.jsonl"),
+        transcriptFile: path.join(workspaceDir, "local-transcript.jsonl"),
+    };
+}
+export class LocalChannelDriver {
+    id = "local";
+    displayName = "Local";
+    get operatorDescription() { return t("operator.local"); }
+    capabilities = {
+        streamingReplies: false,
+        outboundAttachments: false,
+        multiConversation: false,
+        pushInbound: true,
+    };
+    operatorId;
+    inboxFile;
+    transcriptFile;
+    pollIntervalMs;
+    log;
+    handlers = null;
+    timer = null;
+    inboxOffset = 0;
+    pendingLine = "";
+    messageSeq = 0;
+    constructor(options) {
+        this.operatorId = options.operatorId;
+        this.inboxFile = options.inboxFile;
+        this.transcriptFile = options.transcriptFile;
+        this.pollIntervalMs = options.pollIntervalMs ?? 200;
+        this.log = options.log ?? (() => { });
+    }
+    defaultConversation() {
+        return this.directConversation(this.operatorId);
+    }
+    directConversation(senderId) {
+        return {
+            channelId: "local",
+            conversationId: senderId,
+            recipientId: senderId,
+            metadata: { chatType: "direct" },
+        };
+    }
+    start(handlers) {
+        this.handlers = handlers;
+        fs.mkdirSync(path.dirname(this.inboxFile), { recursive: true });
+        // Start at end-of-file so lines left over from earlier runs are ignored.
+        this.inboxOffset = this.measureInboxSize();
+        this.pendingLine = "";
+        this.timer = setInterval(() => {
+            void this.pumpInbox();
+        }, this.pollIntervalMs);
+        this.timer.unref?.();
+        this.log("local_channel_started");
+    }
+    /** Clears the inbox watcher. Not part of ChannelDriver; callers may stop explicitly. */
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+        }
+        this.timer = null;
+        this.handlers = null;
+    }
+    waitUntilReady() {
+        return Promise.resolve();
+    }
+    async sendText(params) {
+        const { target, text, context, log } = params;
+        this.appendTranscript({
+            ts: new Date().toISOString(),
+            direction: "outbound",
+            context,
+            conversationId: target.conversationId,
+            recipientId: target.recipientId,
+            text,
+        });
+        log(`local_send_completed: context=${context} recipient=${target.recipientId} chars=${Array.from(text).length}`);
+        return { status: "sent" };
+    }
+    buildInboundPrompt(text, attachments) {
+        if (attachments.length === 0) {
+            return text;
+        }
+        const lines = attachments.map((attachment) => {
+            const label = attachment.fileName ? ` (${attachment.fileName})` : "";
+            return `- ${attachment.path}${label}`;
+        });
+        return `${text}\n\nLocal attachments:\n${lines.join("\n")}`;
+    }
+    measureInboxSize() {
+        try {
+            return fs.statSync(this.inboxFile).size;
+        }
+        catch {
+            return 0;
+        }
+    }
+    async pumpInbox() {
+        const handlers = this.handlers;
+        if (!handlers) {
+            return;
+        }
+        let size;
+        try {
+            size = fs.statSync(this.inboxFile).size;
+        }
+        catch {
+            return;
+        }
+        if (size < this.inboxOffset) {
+            // The inbox was truncated; restart from the beginning.
+            this.inboxOffset = 0;
+            this.pendingLine = "";
+        }
+        if (size === this.inboxOffset) {
+            return;
+        }
+        let chunk;
+        try {
+            const fd = fs.openSync(this.inboxFile, "r");
+            try {
+                const buffer = Buffer.alloc(size - this.inboxOffset);
+                fs.readSync(fd, buffer, 0, buffer.length, this.inboxOffset);
+                chunk = buffer.toString("utf8");
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        }
+        catch {
+            return;
+        }
+        this.inboxOffset = size;
+        const complete = chunk.endsWith("\n");
+        const combined = this.pendingLine + chunk;
+        const parts = combined.split("\n");
+        this.pendingLine = complete ? "" : (parts.pop() ?? "");
+        for (const line of parts) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                await this.dispatchInboxLine(trimmed, handlers);
+            }
+            catch (error) {
+                this.log(`local_inbound_failed: error=${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    async dispatchInboxLine(line, handlers) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            this.log("local_inbox_invalid_json: skipped one line");
+            return;
+        }
+        if (typeof parsed?.text !== "string" || !parsed.text.trim()) {
+            this.log("local_inbox_invalid_line: skipped one line without text");
+            return;
+        }
+        const senderId = typeof parsed.senderId === "string" && parsed.senderId
+            ? parsed.senderId
+            : this.operatorId;
+        const conversationId = typeof parsed.conversationId === "string" && parsed.conversationId
+            ? parsed.conversationId
+            : senderId;
+        const attachments = Array.isArray(parsed.attachments)
+            ? parsed.attachments.filter((attachment) => Boolean(attachment) &&
+                typeof attachment.path === "string" &&
+                typeof attachment.kind === "string")
+            : [];
+        this.messageSeq += 1;
+        const message = {
+            id: `local-${Date.now().toString(36)}-${this.messageSeq}`,
+            conversation: { ...this.directConversation(senderId), conversationId },
+            senderId,
+            text: parsed.text,
+            attachments,
+            createdAt: new Date().toISOString(),
+        };
+        this.appendTranscript({
+            ts: message.createdAt,
+            direction: "inbound",
+            context: "inbound",
+            conversationId,
+            recipientId: senderId,
+            text: parsed.text,
+        });
+        await handlers.onInboundMessage(message);
+    }
+    appendTranscript(record) {
+        fs.mkdirSync(path.dirname(this.transcriptFile), { recursive: true });
+        fs.appendFileSync(this.transcriptFile, `${JSON.stringify(record)}\n`, "utf8");
+    }
+}

package/dist/channels/wechat/wechat-driver.js

@@ -1,16 +1,25 @@
+// 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 { t } from "../../i18n/index.js";
 import { WECHAT_SEND_MAX_ATTEMPTS, computeWechatSendRetryDelayMs, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, formatWechatSendRetryLogEntry, isRetryableWechatSendError, isWechatContextUnavailableError, } from "../../channels/wechat/wechat-forwarding.js";
 import { describeWechatTransportError, isWechatContextTokenStaleError, } from "../../wechat/wechat-transport.js";
 import { formatDuration } from "../../core/text-utils.js";
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /** Per-recipient typing tickets with a random-refresh TTL and retry backoff. */
 class TypingTicketCache {
+    cache = new Map();
     fetchTicket;
     log;
     ttlMs;
     initialRetryMs;
     maxRetryMs;
-    cache = new Map();
     constructor(fetchTicket, log, ttlMs = 24 * 60 * 60 * 1000, initialRetryMs = 2_000, maxRetryMs = 60 * 60 * 1000) {
+        // Plain assignments instead of parameter properties so Node's
+        // strip-types source mode can load this module.
         this.fetchTicket = fetchTicket;
         this.log = log;
         this.ttlMs = ttlMs;
@@ -59,7 +68,7 @@ const WECHAT_CONTEXT_STALE_HINT = "WeChat conversation context is stale or unava
 export class WechatChannelDriver {
     id = "wechat";
     displayName = "WeChat";
-    operatorDescription = "the configured WeChat owner";
+    get operatorDescription() { return t("operator.wechat"); }
     capabilities = {
         streamingReplies: false,
         outboundAttachments: false,

package/dist/channels/wecom/wecom-driver.js

@@ -1,3 +1,10 @@
+// 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 { t } from "../../i18n/index.js";
 import { buildWecomInboundPrompt, formatWecomVisibleText, } from "./wecom-message.js";
 import { truncatePreview } from "../../core/text-utils.js";
 export function toWecomOutputKind(context) {
@@ -22,7 +29,7 @@ export function toWecomOutputKind(context) {
 export class WecomChannelDriver {
     id = "wecom";
     displayName = "WeCom";
-    operatorDescription = "the paired WeCom operator";
+    get operatorDescription() { return t("operator.wecom"); }
     capabilities = {
         streamingReplies: true,
         outboundAttachments: true,