cli-wechat-bridge 1.2.1 → 1.2.3

package/dist/daemon/wechat-daemon.js

@@ -12,6 +12,9 @@ import { execFileSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { resolveDefaultAdapterCommand, } from "../bridge/bridge-adapters.js";
 import { t } from "../i18n/index.js";
+import { handleLanguageControl } from "../bridge/language-control.js";
+import { parseBridgeControlCommand } from "../core/bridge-control.js";
+import { LANGUAGE_FILE } from "../wechat/channel-config.js";
 import { delay, getSharedSessionIdFromAdapterState, quoteWindowsCommandArg, } from "../bridge/bridge-adapters.shared.js";
 import { BridgeController } from "../bridge/bridge-controller.js";
 import { readBridgeLockFile, } from "../bridge/bridge-state.js";
@@ -36,10 +39,15 @@ import { forwardBridgeEvent } from "../core/bridge-event-forwarder.js";
 import { isDirectModuleRun } from "../core/direct-run.js";
 import { WechatChannelPort } from "../channels/wechat/wechat-channel-port.js";
 import { ensureWecomAccount } from "../channels/wecom/setup.js";
+import { ensureTelegramAccount } from "../channels/telegram/setup.js";
+import { TelegramTransport } from "../channels/telegram/telegram-transport.js";
+import { TelegramChannelPort } from "../channels/telegram/telegram-channel-port.js";
 import { WecomChannelPort } from "../channels/wecom/wecom-channel-port.js";
 import { WecomTransport } from "../channels/wecom/wecom-transport.js";
-import { WecomChannelDriver } from "../channels/wecom/wecom-driver.js";
-import { WechatChannelDriver } from "../channels/wechat/wechat-driver.js";
+import { createChannelDriver } from "../channels/channel-driver-factory.js";
+import { LocalChannelPort } from "../channels/local/local-channel-port.js";
+import { getLocalChannelFiles, LOCAL_CHANNEL_OPERATOR_ID, } from "../channels/local/local-driver.js";
+import { getBridgeChannelDisplayName, isBridgeChannelId, normalizeBridgeChannelId, } from "../core/channel-types.js";
 import { clearLocalCompanionEndpoint, clearLocalCompanionOccupancy, readLocalCompanionEndpoint, } from "../companion/local-companion-link.js";
 import { attachDaemonRequestListener, buildDaemonToken, clearDaemonEndpoint, DAEMON_PROTOCOL_VERSION, isPidAlive, readDaemonEndpoint, sendDaemonRequest, sendDaemonResponse, writeDaemonEndpoint, } from "./daemon-link.js";
 const MODULE_FILE = fileURLToPath(import.meta.url);
@@ -60,7 +68,8 @@ const MAX_DAEMON_DEFERRED_INPUTS = 32;
 const DAEMON_ADAPTERS = ["codex", "claude", "opencode", "pi"];
 function getCliChannelId(argv = process.argv.slice(2)) {
     const index = argv.indexOf("--channel");
-    return index >= 0 && argv[index + 1] === "wecom" ? "wecom" : "wechat";
+    const value = index >= 0 ? argv[index + 1] : undefined;
+    return normalizeBridgeChannelId(value);
 }
 function log(message) {
     process.stderr.write(`[${getCliChannelId()}-daemon] ${message}\n`);
@@ -132,11 +141,12 @@ export function parseDaemonCliArgs(argv) {
         }
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
+            const channelDisplayName = getBridgeChannelDisplayName(channelId);
             process.stdout.write([
                 `Usage: ${channelId}-daemon [--cwd <path>] [--adapter <codex|claude|opencode|pi>] [--profile <name-or-path>] [--no-open]`,
                 "",
-                `Keeps one ${channelId === "wecom" ? "WeCom" : "WeChat"} connection alive and switches between Codex, Claude Code, OpenCode, and Pi.`,
-                `Send /codex, /claude, /opencode, or /pi in ${channelId === "wecom" ? "WeCom" : "WeChat"} to switch the active terminal.`,
+                `Keeps one ${channelDisplayName} connection alive and switches between Codex, Claude Code, OpenCode, and Pi.`,
+                `Send /codex, /claude, /opencode, or /pi in ${channelDisplayName} to switch the active terminal.`,
                 "",
             ].join("\n"));
             process.exit(0);
@@ -150,7 +160,7 @@ export function parseDaemonCliArgs(argv) {
             continue;
         }
         if (arg === "--channel") {
-            if (!next || (next !== "wechat" && next !== "wecom")) {
+            if (!isBridgeChannelId(next)) {
                 throw new Error(`Invalid channel: ${next ?? "(missing)"}`);
             }
             channelId = next;
@@ -184,7 +194,7 @@ export function parseDaemonCliArgs(argv) {
         profile,
         initialAdapter,
         openVisible,
-        ...(channelId === "wecom" ? { channelId } : {}),
+        ...(channelId === "wechat" ? {} : { channelId }),
     };
 }
 export function parseDaemonSwitchCommand(text) {
@@ -323,8 +333,29 @@ function shellQuotePosix(s) {
 function formatLaunchPreview(launch) {
     return [launch.command, ...launch.args].join(" ");
 }
-function openVisibleClient(params) {
+export function openVisibleClient(params) {
     const args = buildVisibleClientLaunchArgs(params);
+    // E2E harness override: host the visible client in a PTY owned by an
+    // external launcher script instead of a terminal window, so automated
+    // runs can type and read the TUI while every other step stays identical.
+    const launcherOverride = process.env.CLI_BRIDGE_VISIBLE_LAUNCHER;
+    if (launcherOverride) {
+        const child = spawn(process.execPath, [launcherOverride, ...args], {
+            cwd: params.cwd,
+            env: process.env,
+            detached: true,
+            stdio: "ignore",
+        });
+        child.once("error", (error) => {
+            params.onError?.(error instanceof Error ? error : new Error(String(error)));
+        });
+        child.unref();
+        return {
+            command: process.execPath,
+            args: [launcherOverride, ...args],
+            pid: child.pid,
+        };
+    }
     if (process.platform === "win32") {
         const command = process.env.ComSpec || "cmd.exe";
         const launchArgs = [
@@ -490,57 +521,44 @@ function formatInboundMessagePreview(message) {
     return "(empty)";
 }
 function formatNoActiveAdapterMessage() {
-    return [
-        "No active terminal is selected.",
-        "Send /codex, /claude, /opencode, or /pi to choose one.",
-    ].join("\n");
+    return t("daemon.noActiveAdapter");
 }
 export function formatDaemonSwitchResultDetail(result) {
-    if (result.activated === false) {
-        const previous = result.previousActiveAdapter
-            ? ` Active terminal remains ${result.previousActiveAdapter}.`
-            : " No terminal is active yet.";
-        if (result.visibleConnected && result.visibleReady === false) {
-            return `The visible Codex CLI connected, but its active thread is not ready yet.${previous} Check ${BRIDGE_LOG_FILE}.`;
-        }
-        if (result.openedVisible) {
-            return result.created
-                ? `Started the bridge slot and tried to open the visible CLI, but it has not connected yet.${previous} Check ${BRIDGE_LOG_FILE}.`
-                : `Tried to open a visible CLI for the existing slot, but it has not connected yet.${previous} Check ${BRIDGE_LOG_FILE}.`;
-        }
-        return `The visible CLI is not connected yet.${previous} Check ${BRIDGE_LOG_FILE}.`;
-    }
-    if (result.openedVisible && result.visibleConnected) {
-        return result.created
-            ? "Started a new visible CLI."
-            : "Opened a visible CLI for the existing slot.";
-    }
-    if (result.openedVisible) {
-        return result.created
-            ? `Started the bridge slot and tried to open the visible CLI, but it has not connected yet. Check ${BRIDGE_LOG_FILE}.`
-            : `Tried to open a visible CLI for the existing slot, but it has not connected yet. Check ${BRIDGE_LOG_FILE}.`;
-    }
-    if (result.visibleConnected) {
-        return "Reused the existing visible CLI.";
-    }
-    return result.created ? "Started the bridge slot." : "Reused the bridge slot.";
+    const previous = result.activated === false
+        ? result.previousActiveAdapter
+            ? t("daemon.switch.previous", { adapter: result.previousActiveAdapter })
+            : t("daemon.switch.none")
+        : "";
+    if (result.activated === false && result.visibleConnected && result.visibleReady === false) {
+        return t("daemon.switch.threadNotReady", { previous, log: BRIDGE_LOG_FILE });
+    }
+    if (result.openedVisible && (result.activated === false || !result.visibleConnected)) {
+        return t(result.created ? "daemon.switch.newNotConnected" : "daemon.switch.existingNotConnected", { previous, log: BRIDGE_LOG_FILE });
+    }
+    if (result.activated === false)
+        return t("daemon.switch.notConnected", { previous, log: BRIDGE_LOG_FILE });
+    if (result.openedVisible && result.visibleConnected)
+        return t(result.created ? "daemon.switchResult.new" : "daemon.switch.opened");
+    if (result.visibleConnected)
+        return t("daemon.switchResult.reused");
+    return t(result.created ? "daemon.switch.slotStarted" : "daemon.switch.slotReused");
 }
 export function formatDaemonStatus(status) {
     const lines = [
-        "wechat-daemon status",
-        `cwd: ${status.cwd}`,
-        `active: ${status.activeAdapter ?? "(none)"}`,
-        `started_at: ${status.startedAt}`,
+        t("status.daemon", { channel: status.channelId ?? "wechat" }),
+        `${t("status.label.cwd")}: ${status.cwd}`,
+        `${t("status.label.active")}: ${status.activeAdapter ?? t("status.none")}`,
+        `${t("status.label.started_at")}: ${status.startedAt}`,
     ];
     for (const adapter of DAEMON_ADAPTERS) {
         const slot = status.slots.find((entry) => entry.adapter === adapter);
         if (!slot) {
-            lines.push(`${adapter}: not started`);
+            lines.push(`${adapter}: ${t("status.notStarted")}`);
             continue;
         }
         const flags = [
-            slot.pendingApproval ? "pending_approval" : "",
-            slot.pendingUserInput ? "pending_input" : "",
+            slot.pendingApproval ? t("status.pendingApproval") : "",
+            slot.pendingUserInput ? t("status.pendingInput") : "",
             slot.companionPid ? `companion_pid=${slot.companionPid}` : "",
         ].filter(Boolean);
         lines.push(`${adapter}: ${slot.status}${flags.length ? ` (${flags.join(", ")})` : ""}`);
@@ -555,6 +573,8 @@ export class WechatDaemon {
     channelDriver;
     channelId;
     wecomTransport;
+    telegramTransport;
+    localFiles;
     inboundConversationContext = new InboundConversationContext();
     fallbackConversation;
     slots = new Map();
@@ -582,19 +602,21 @@ export class WechatDaemon {
         this.transport = params.transport;
         this.channelId = params.channelId ?? "wechat";
         this.wecomTransport = params.wecomTransport ?? null;
+        this.telegramTransport = params.telegramTransport ?? null;
+        this.localFiles = params.localFiles ?? null;
         this.deps = params.deps ?? {};
-        this.channelDriver = this.wecomTransport
-            ? new WecomChannelDriver({
-                transport: this.wecomTransport,
-                accountId: params.accountId,
-                operatorId: params.authorizedUserId,
-                logError,
-            })
-            : new WechatChannelDriver({
-                transport: this.transport,
-                logError,
-                buildInboundPrompt: (text, attachments) => buildWechatInboundPrompt(text, attachments.filter((attachment) => attachment.kind === "image" || attachment.kind === "file")),
-            });
+        this.channelDriver = createChannelDriver({
+            channelId: this.channelId,
+            authorizedUserId: params.authorizedUserId,
+            accountId: params.accountId,
+            wechatTransport: this.transport,
+            wecomTransport: this.wecomTransport,
+            telegramTransport: this.telegramTransport,
+            localFiles: this.localFiles,
+            buildWechatInboundPrompt: (text, attachments) => buildWechatInboundPrompt(text, attachments.filter((attachment) => attachment.kind === "image" || attachment.kind === "file")),
+            log: (message) => this.daemonLog(message),
+            logError,
+        });
         this.fallbackConversation = this.channelDriver.defaultConversation()
             ?? this.channelDriver.directConversation(params.authorizedUserId);
         this.pendingWechatMessages = this.deps.pendingWechatMessages ??
@@ -716,7 +738,7 @@ export class WechatDaemon {
                     if (chatType === "direct") {
                         const result = await this.channelDriver.sendText({
                             target: this.channelDriver.directConversation(senderId),
-                            text: "Unauthorized.",
+                            text: t("channel.unauthorized"),
                             context: "notice",
                             log: appendDaemonLog,
                         });
@@ -743,6 +765,7 @@ export class WechatDaemon {
         appendDaemonLog(`started: channel=${this.channelId} cwd=${this.cwd}`);
         const activeSlot = this.getActiveSlot();
         const welcomeText = t("daemon.welcome", {
+            channel: this.channelDriver.displayName,
             cwd: this.cwd,
             adapter: activeSlot?.adapter ?? "none",
             bindings: formatBindingsListMessage(listBindings()),
@@ -756,6 +779,9 @@ export class WechatDaemon {
             return;
         }
         while (!this.shutdownPromise) {
+            if (!this.transport) {
+                throw new Error("The wechat poll loop requires a WeChat transport.");
+            }
             let pollResult;
             try {
                 pollResult = await this.transport.pollMessages({
@@ -853,7 +879,7 @@ export class WechatDaemon {
         // the process alive until the 35-second poll timeout and retain the daemon
         // endpoint for the next startup to clean up.
         try {
-            this.transport.stop();
+            this.transport?.stop();
         }
         catch {
             // Best effort shutdown.
@@ -870,6 +896,12 @@ export class WechatDaemon {
         catch {
             // Best effort shutdown.
         }
+        try {
+            await this.telegramTransport?.stop();
+        }
+        catch {
+            // Best effort shutdown.
+        }
         clearDaemonEndpoint();
         for (const slot of this.slots.values()) {
             try {
@@ -1081,12 +1113,12 @@ export class WechatDaemon {
             remindPendingUserInput: async () => {
                 routeMessage = prefixDaemonAdapterMessage(slot.adapter, slot.pendingUserInput
                     ? formatPendingUserInputReminder(slot.pendingUserInput)
-                    : `${slot.adapter} is waiting for structured input. Reply with /answer <key>=<value> ...`);
+                    : t("bridge.input.waiting", { adapter: slot.adapter }));
                 reason = "pending_user_input";
                 await sendReminder(routeMessage, "user_input_required");
             },
             remindBusy: async () => {
-                routeMessage = prefixDaemonAdapterMessage(slot.adapter, `${slot.adapter} is still working. Wait for the current reply or use /stop.`);
+                routeMessage = prefixDaemonAdapterMessage(slot.adapter, t("bridge.busy.remote", { adapter: slot.adapter }));
                 reason = "busy";
                 await sendReminder(routeMessage, "notice");
             },
@@ -1362,7 +1394,7 @@ export class WechatDaemon {
         }
         else if (slot.adapter === "opencode" || slot.adapter === "pi") {
             if (!slot.runtime.createSession) {
-                throw new Error(`/new is not available in ${slot.adapter} mode.`);
+                throw new Error(t("bridge.newSession.unavailable", { adapter: slot.adapter }));
             }
             await slot.runtime.createSession();
         }
@@ -1379,12 +1411,38 @@ export class WechatDaemon {
                 },
             });
         }
+        if (this.channelId === "telegram") {
+            return new TelegramChannelPort({
+                transport: this.telegramTransport,
+                sendText: (target, text, kind) => this.queueWechatMessage(this.authorizedUserId, text, toWechatSendContext(kind), target),
+                prefixText: (currentAdapter, text) => prefixDaemonAdapterMessage(currentAdapter ?? adapter, text),
+                onEmptyVisibleReply: (currentAdapter, rawText) => {
+                    appendDaemonLog(`empty_visible_final_reply: adapter=${currentAdapter ?? adapter} raw=${truncatePreview(rawText)}`);
+                },
+            });
+        }
+        if (this.channelId === "local") {
+            return new LocalChannelPort({
+                sendText: (recipientId, text, context) => this.queueWechatMessage(recipientId, text, context),
+                prefixText: (currentAdapter, text) => prefixDaemonAdapterMessage(currentAdapter ?? adapter, text),
+                onEmptyVisibleReply: (currentAdapter, rawText) => {
+                    appendDaemonLog(`empty_visible_final_reply: adapter=${currentAdapter ?? adapter} raw=${truncatePreview(rawText)}`);
+                },
+                onTextSent: (currentAdapter, text) => {
+                    appendDaemonLog(`final_reply_sent: adapter=${currentAdapter ?? adapter} chars=${Array.from(text).length}`);
+                },
+            });
+        }
+        if (!this.transport) {
+            throw new Error("The wechat channel port requires a WeChat transport.");
+        }
+        const transport = this.transport;
         return new WechatChannelPort({
             sendText: (recipientId, text, context) => this.queueWechatMessage(recipientId, text, context),
-            sendImage: (recipientId, filePath) => this.queueWechatAttachmentAction(() => this.transport.sendImage(filePath, { recipientId })),
-            sendFile: (recipientId, filePath) => this.queueWechatAttachmentAction(() => this.transport.sendFile(filePath, { recipientId })),
-            sendVoice: (recipientId, filePath) => this.queueWechatAttachmentAction(() => this.transport.sendVoice(filePath, recipientId)),
-            sendVideo: (recipientId, filePath) => this.queueWechatAttachmentAction(() => this.transport.sendVideo(filePath, { recipientId })),
+            sendImage: (recipientId, filePath) => this.queueWechatAttachmentAction(() => transport.sendImage(filePath, { recipientId })),
+            sendFile: (recipientId, filePath) => this.queueWechatAttachmentAction(() => transport.sendFile(filePath, { recipientId })),
+            sendVoice: (recipientId, filePath) => this.queueWechatAttachmentAction(() => transport.sendVoice(filePath, recipientId)),
+            sendVideo: (recipientId, filePath) => this.queueWechatAttachmentAction(() => transport.sendVideo(filePath, { recipientId })),
             prefixText: (currentAdapter, text) => prefixDaemonAdapterMessage(currentAdapter ?? adapter, text),
             onEmptyVisibleReply: (currentAdapter, rawText) => {
                 appendDaemonLog(`empty_visible_final_reply: adapter=${currentAdapter ?? adapter} raw=${truncatePreview(rawText)}`);
@@ -1402,10 +1460,18 @@ export class WechatDaemon {
             ? this.resolveSlotOutputTarget(slot)
             : this.fallbackConversation;
         const eventTask = slot.turns.activeTask;
+        if (adapterState.pendingApprovals !== undefined) {
+            const previous = new Map(slot.pendingConfirmations.map((pending) => [pending.requestId, pending]));
+            slot.pendingConfirmations = adapterState.pendingApprovals.map((request) => {
+                const existing = previous.get(request.requestId);
+                return existing ? { ...existing, ...request } : toPendingApproval({ type: "approval_required", request, timestamp: nowIso() });
+            });
+        }
         if (slot.pendingConfirmations.length > 0 && !adapterState.pendingApproval) {
             slot.pendingConfirmations = [];
         }
-        if (slot.pendingUserInput && !adapterState.pendingUserInput) {
+        if (slot.pendingUserInput && (!adapterState.pendingUserInput
+            || (slot.pendingUserInput.requestId !== undefined && slot.pendingUserInput.requestId !== adapterState.pendingUserInput.requestId))) {
             slot.pendingUserInput = null;
         }
         slot.eventForwardChain = slot.eventForwardChain
@@ -1452,17 +1518,29 @@ export class WechatDaemon {
             },
             approvalRequired: (next) => {
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
+                    const liveState = slot.runtime.getState();
+                    if (liveState.pendingApprovals !== undefined && liveState.pendingApproval?.requestId !== next.request.requestId)
+                        return;
                     const pending = toPendingApproval(next);
-                    slot.pendingConfirmations.push(pending);
+                    if (liveState.pendingApprovals === undefined) {
+                        slot.pendingConfirmations = [pending];
+                    }
                     appendDaemonLog(`approval_required: adapter=${slot.adapter} source=${pending.source} command=${truncatePreview(pending.commandPreview)}`);
-                    await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatApprovalMessage(pending, adapterState)), "approval_required", eventTarget);
+                    await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatApprovalMessage(pending, liveState)), "approval_required", eventTarget);
+                    if (slot.runtime.getState().pendingApproval?.requestId === pending.requestId) {
+                        slot.displayedApprovalRequestId = pending.requestId;
+                    }
                 }));
             },
             userInputRequired: (next) => {
+                if (next.request.requestId !== undefined && slot.runtime.getState().pendingUserInput?.requestId !== next.request.requestId)
+                    return;
                 const pending = toPendingUserInput(next.request);
                 slot.pendingUserInput = pending;
                 appendDaemonLog(`user_input_required: adapter=${slot.adapter} questions=${pending.questions.length}`);
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
+                    if (pending.requestId !== undefined && slot.runtime.getState().pendingUserInput?.requestId !== pending.requestId)
+                        return;
                     await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatUserInputRequestMessage(pending, adapterState)), "user_input_required", eventTarget);
                 }));
             },
@@ -1561,7 +1639,12 @@ export class WechatDaemon {
     }
     async handleInboundMessage(message) {
         if (message.senderId !== this.authorizedUserId) {
-            await this.queueWechatMessage(message.senderId, `Unauthorized. This daemon only accepts messages from ${this.channelDriver.operatorDescription}.`);
+            await this.queueWechatMessage(message.senderId, t("bridge.unauthorized", { mode: t("bridge.mode.daemon"), operator: this.channelDriver.operatorDescription }));
+            return;
+        }
+        const languageCommand = parseBridgeControlCommand(message.text);
+        if (languageCommand?.type === "language") {
+            await this.handleLanguageCommand(message.senderId, languageCommand.target);
             return;
         }
         const emojiMatch = resolveEmojiCommand(message.text);
@@ -1578,7 +1661,7 @@ export class WechatDaemon {
                 }
                 else {
                     const detail = formatDaemonSwitchResultDetail(result);
-                    await this.queueWechatMessage(message.senderId, `Could not activate terminal: ${switchTarget}.\n${detail}`);
+                    await this.queueWechatMessage(message.senderId, t("daemon.activateFailed", { adapter: switchTarget, detail }));
                     return;
                 }
             }
@@ -1597,7 +1680,7 @@ export class WechatDaemon {
             });
             const detail = formatDaemonSwitchResultDetail(result);
             if (!result.activated) {
-                await this.queueWechatMessage(message.senderId, `Could not activate terminal: ${switchDirective.adapter}.\n${detail}`);
+                await this.queueWechatMessage(message.senderId, t("daemon.activateFailed", { adapter: switchDirective.adapter, detail }));
                 return;
             }
             this.bindCurrentWecomConversation(this.getActiveSlot());
@@ -1605,12 +1688,12 @@ export class WechatDaemon {
                 message = { ...message, text: switchDirective.remainder };
             }
             else {
-                await this.queueWechatMessage(message.senderId, `Active terminal: ${switchDirective.adapter}.\n${detail}`);
+                await this.queueWechatMessage(message.senderId, t("daemon.activeTerminal", { adapter: switchDirective.adapter, detail }));
                 return;
             }
         }
         if (message.text.trim().toLowerCase() === "/daemon-stop") {
-            await this.queueWechatMessage(message.senderId, `Stopping ${this.channelId}-daemon...`);
+            await this.queueWechatMessage(message.senderId, t("daemon.stopping", { channel: this.channelId }));
             setTimeout(() => {
                 void this.shutdown().finally(() => process.exit(0));
             }, 0);
@@ -1651,10 +1734,10 @@ export class WechatDaemon {
                 remindPendingUserInput: async () => {
                     await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(currentSlot.adapter, currentSlot.pendingUserInput
                         ? formatPendingUserInputReminder(currentSlot.pendingUserInput)
-                        : `${currentSlot.adapter} is waiting for structured input. Reply with /answer <key>=<value> ...`));
+                        : t("bridge.input.waiting", { adapter: currentSlot.adapter })));
                 },
                 remindBusy: async () => {
-                    await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(currentSlot.adapter, `${currentSlot.adapter} is still working. Wait for the current reply or use /stop.`));
+                    await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(currentSlot.adapter, t("bridge.busy.remote", { adapter: currentSlot.adapter })));
                 },
                 defer: async () => undefined,
                 dispatch: async () => {
@@ -1702,20 +1785,23 @@ export class WechatDaemon {
             }
             case "bind": {
                 setBinding(cmd.emoji, cmd.command);
-                await this.queueWechatMessage(senderId, `Bound ${cmd.emoji} → ${cmd.command}`);
+                await this.queueWechatMessage(senderId, t("binding.bound", { emoji: cmd.emoji, command: cmd.command }));
                 return;
             }
             case "unbind": {
                 const removed = removeBinding(cmd.emoji);
                 await this.queueWechatMessage(senderId, removed
-                    ? `Unbound ${cmd.emoji}`
-                    : `No binding found for ${cmd.emoji}`);
+                    ? t("binding.unbound", { emoji: cmd.emoji })
+                    : t("binding.notFound", { emoji: cmd.emoji }));
                 return;
             }
         }
     }
     async handleSystemCommand(message, activeSlot, command) {
         switch (command.type) {
+            case "language":
+                await this.handleLanguageCommand(message.senderId, command.target);
+                return;
             case "model":
             case "plan":
                 await this.queueWechatMessage(message.senderId, await handleAdapterControl(activeSlot.runtime, message.senderId, command));
@@ -1725,7 +1811,7 @@ export class WechatDaemon {
                 return;
             case "resume": {
                 if (!isWechatResumeEnabled(activeSlot.adapter)) {
-                    await this.queueWechatMessage(message.senderId, `${this.channelDriver.displayName} /resume is disabled for ${activeSlot.adapter} in daemon mode. Use /resume directly inside the visible terminal; the remote channel will follow that local session.`);
+                    await this.queueWechatMessage(message.senderId, t("daemon.resume.disabled", { channel: this.channelDriver.displayName, adapter: activeSlot.adapter }));
                     return;
                 }
                 try {
@@ -1757,7 +1843,7 @@ export class WechatDaemon {
             }
             case "new_session":
                 if (!activeSlot.runtime.createSession) {
-                    await this.queueWechatMessage(message.senderId, `/new is not available in ${activeSlot.adapter} mode.`);
+                    await this.queueWechatMessage(message.senderId, t("bridge.newSession.unavailable", { adapter: activeSlot.adapter }));
                     return;
                 }
                 await activeSlot.outputBatcher.flushNow();
@@ -1774,8 +1860,8 @@ export class WechatDaemon {
             case "stop": {
                 const interrupted = await activeSlot.runtime.interrupt();
                 await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, interrupted
-                    ? "Interrupt signal sent to the active worker."
-                    : "No running worker was available to interrupt."));
+                    ? t("bridge.interrupt.workerSent")
+                    : t("bridge.interrupt.workerIdle")));
                 return;
             }
             case "reset":
@@ -1786,7 +1872,7 @@ export class WechatDaemon {
                 activeSlot.resumeCoordinator.clear();
                 await activeSlot.runtime.reset();
                 appendDaemonLog(`reset: adapter=${activeSlot.adapter}`);
-                await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, "Worker session has been reset."));
+                await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, t("bridge.reset.done")));
                 return;
             case "confirm":
                 await this.confirmPendingApproval(message, activeSlot);
@@ -1799,42 +1885,49 @@ export class WechatDaemon {
                 return;
         }
     }
+    async handleLanguageCommand(senderId, target) {
+        await this.queueWechatMessage(senderId, await handleLanguageControl({
+            target,
+            settingsFile: this.deps.localeSettingsFile ?? LANGUAGE_FILE,
+            adapters: [...this.slots.values()].map((slot) => slot.runtime),
+        }));
+    }
     async confirmPendingApproval(message, activeSlot) {
         const slot = this.resolvePendingApprovalSlot(activeSlot);
         if (!slot || slot.pendingConfirmations.length === 0) {
-            await this.queueWechatMessage(message.senderId, "No pending approval request.");
+            await this.queueWechatMessage(message.senderId, t("approval.noPending"));
             return;
         }
-        const count = await slot.runtime.resolveAllApprovals("confirm");
+        const pending = slot.pendingConfirmations[0];
+        const count = await slot.runtime.resolveApproval("confirm", slot.runtime.getState().pendingApprovals !== undefined ? slot.displayedApprovalRequestId ?? "" : pending.requestId) ? 1 : 0;
         if (!count) {
-            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, "The worker could not apply this approval request."));
+            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, t("bridge.approval.applyFailed")));
             return;
         }
-        const preview = slot.pendingConfirmations[0]?.commandPreview ?? "";
-        slot.pendingConfirmations = [];
-        slot.turns.setActiveTask({
-            startedAt: Date.now(),
-            inputPreview: preview,
-        });
+        const preview = pending.commandPreview;
+        const adapterState = slot.runtime.getState();
+        slot.pendingConfirmations = (adapterState.pendingApprovals ?? (adapterState.pendingApproval ? [adapterState.pendingApproval] : []))
+            .map((request) => toPendingApproval({ type: "approval_required", request, timestamp: nowIso() }));
         appendDaemonLog(`approval_confirmed: adapter=${slot.adapter} count=${count} command=${truncatePreview(preview)}`);
-        await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, count > 1
-            ? `${count} approvals confirmed. Continuing...`
-            : "Approval confirmed. Continuing..."));
+        await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, t("approval.confirmed")));
     }
     async denyPendingApproval(message, activeSlot) {
         const slot = this.resolvePendingApprovalSlot(activeSlot);
         if (!slot || slot.pendingConfirmations.length === 0) {
-            await this.queueWechatMessage(message.senderId, "No pending approval request.");
+            await this.queueWechatMessage(message.senderId, t("approval.noPending"));
             return;
         }
-        const count = await slot.runtime.resolveAllApprovals("deny");
+        const pending = slot.pendingConfirmations[0];
+        const count = await slot.runtime.resolveApproval("deny", slot.runtime.getState().pendingApprovals !== undefined ? slot.displayedApprovalRequestId ?? "" : pending.requestId) ? 1 : 0;
         if (!count) {
-            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, "The worker could not deny this approval request cleanly."));
+            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, t("bridge.approval.denyFailed")));
             return;
         }
-        slot.pendingConfirmations = [];
+        const adapterState = slot.runtime.getState();
+        slot.pendingConfirmations = (adapterState.pendingApprovals ?? (adapterState.pendingApproval ? [adapterState.pendingApproval] : []))
+            .map((request) => toPendingApproval({ type: "approval_required", request, timestamp: nowIso() }));
         appendDaemonLog(`approval_denied: adapter=${slot.adapter} count=${count}`);
-        await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, count > 1 ? `${count} approvals denied.` : "Approval denied."));
+        await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, t("approval.denied")));
     }
     async answerPendingUserInput(message, activeSlot, raw) {
         // Mirror the /confirm and /deny behavior: search every slot for a pending
@@ -1842,12 +1935,12 @@ export class WechatDaemon {
         // when the user has since switched the active adapter.
         const slot = this.resolvePendingUserInputSlot(activeSlot);
         if (!slot) {
-            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, "No pending user input request."));
+            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, t("bridge.answer.none")));
             return;
         }
         const pending = slot.pendingUserInput;
         if (!pending) {
-            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, "No pending user input request."));
+            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, t("bridge.answer.none")));
             return;
         }
         const parsed = parsePendingUserInputAnswerCommand(raw, pending);
@@ -1855,18 +1948,15 @@ export class WechatDaemon {
             await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, parsed.error));
             return;
         }
-        const submitted = await slot.runtime.submitUserInput(parsed.answers);
+        const submitted = await slot.runtime.submitUserInput(parsed.answers, pending.requestId);
         if (!submitted) {
-            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, "The worker could not apply this answer."));
+            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, t("bridge.answer.failed")));
             return;
         }
-        slot.pendingUserInput = null;
-        slot.turns.setActiveTask({
-            startedAt: Date.now(),
-            inputPreview: parsed.preview,
-        });
+        if (slot.pendingUserInput?.requestId === pending.requestId)
+            slot.pendingUserInput = null;
         appendDaemonLog(`user_input_answered: adapter=${slot.adapter} preview=${parsed.preview}`);
-        await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, "Answer submitted. Continuing..."));
+        await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, t("bridge.answer.sent")));
     }
     resolvePendingUserInputSlot(activeSlot) {
         if (activeSlot.pendingUserInput) {
@@ -1904,14 +1994,14 @@ export class WechatDaemon {
             .map((adapter) => this.slots.get(adapter))
             .filter((slot) => Boolean(slot));
         if (startedSlots.length === 0) {
-            await this.queueWechatMessage(message.senderId, "/all needs at least one running adapter. Open one first with /codex, /claude, /opencode, or /pi.");
+            await this.queueWechatMessage(message.senderId, t("daemon.broadcast.empty"));
             return;
         }
         const busySlots = startedSlots.filter((slot) => this.isSlotBusyForBroadcast(slot));
         if (busySlots.length > 0) {
             const names = busySlots.map((slot) => slot.adapter).join(", ");
             appendDaemonLog(`broadcast_canceled_busy: busy=[${names}]`);
-            await this.queueWechatMessage(message.senderId, `/all canceled: ${busySlots.length > 1 ? "these workers are" : "this worker is"} still busy — ${names}. Wait for the current replies or use /stop first.`);
+            await this.queueWechatMessage(message.senderId, t("daemon.broadcast.busy", { workers: t(busySlots.length > 1 ? "daemon.broadcast.multipleBusy" : "daemon.broadcast.singleBusy"), names }));
             return;
         }
         const broadcastMessage = { ...message, text };
@@ -1928,10 +2018,10 @@ export class WechatDaemon {
             dispatched.push(adapter);
         }
         const lines = [
-            `Broadcast dispatched to ${dispatched.length} ${dispatched.length > 1 ? "workers" : "worker"}: ${dispatched.join(", ")}. Each reply arrives prefixed with its adapter name.`,
+            t("daemon.broadcast.sent", { count: dispatched.length, workers: t(dispatched.length > 1 ? "daemon.broadcast.multipleWorkers" : "daemon.broadcast.singleWorker"), names: dispatched.join(", ") }),
         ];
         if (skipped.length > 0) {
-            lines.push(`Not started (skipped): ${skipped.join(", ")}. Start them with their /command to include them next time.`);
+            lines.push(t("daemon.broadcast.skipped", { names: skipped.join(", ") }));
         }
         await this.queueWechatMessage(message.senderId, lines.join("\n"));
     }
@@ -1948,7 +2038,7 @@ export class WechatDaemon {
             task: nextTask,
             conversation: inboundConversation,
             onBusy: async () => {
-                await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, `${slot.adapter} is still working. Wait for the current reply or use /stop.`), "notice", conversationOverride);
+                await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, t("bridge.busy.remote", { adapter: slot.adapter })), "notice", conversationOverride);
             },
             forward: async () => {
                 appendDaemonLog(`forwarded_input: adapter=${slot.adapter} text=${truncatePreview(preview)}`);
@@ -2344,25 +2434,36 @@ export async function runDaemon(options) {
     const wecomAccount = options.channelId === "wecom"
         ? await ensureWecomAccount({ log })
         : null;
+    const telegramAccount = options.channelId === "telegram"
+        ? await ensureTelegramAccount({ log })
+        : null;
     const credentials = wecomAccount
         ? { userId: wecomAccount.operatorUserId }
-        : await ensureWechatCredentials({
-            requireUserId: true,
-            validateExisting: true,
-            log,
-        });
+        : telegramAccount
+            ? { userId: telegramAccount.operatorUserId }
+            : options.channelId === "local"
+                ? { userId: LOCAL_CHANNEL_OPERATOR_ID }
+                : await ensureWechatCredentials({
+                    requireUserId: true,
+                    validateExisting: true,
+                    log,
+                });
     if (!credentials.userId) {
         throw new Error(options.channelId === "wecom"
             ? "Saved WeCom credentials are missing operatorUserId."
-            : "Saved WeChat credentials are missing userId.");
+            : options.channelId === "telegram"
+                ? "Saved Telegram credentials are missing operatorUserId."
+                : "Saved WeChat credentials are missing userId.");
     }
     const daemon = new WechatDaemon({
         cwd: options.cwd,
         profile: options.profile,
         authorizedUserId: credentials.userId,
-        transport: new WeChatTransport({ log, logError }),
+        transport: (options.channelId ?? "wechat") === "wechat"
+            ? new WeChatTransport({ log, logError })
+            : null,
         channelId: options.channelId,
-        accountId: wecomAccount?.botId,
+        accountId: wecomAccount?.botId ?? telegramAccount?.botUsername,
         wecomTransport: wecomAccount
             ? new WecomTransport({
                 account: wecomAccount,
@@ -2372,6 +2473,18 @@ export async function runDaemon(options) {
                 },
             })
             : null,
+        telegramTransport: telegramAccount
+            ? new TelegramTransport({
+                account: telegramAccount,
+                logger: {
+                    log: (message) => log(message),
+                    error: (message) => logError(message),
+                },
+            })
+            : null,
+        localFiles: options.channelId === "local"
+            ? getLocalChannelFiles(options.cwd)
+            : null,
     });
     if (cleanupResult.action === "stopped" && isDaemonAdapterKind(cleanupResult.lock.adapter)) {
         daemon.takenOverAdapter = cleanupResult.lock.adapter;