cli-wechat-bridge 1.2.1 → 1.2.3

package/dist/companion/local-companion-start.js

@@ -5,13 +5,17 @@
 // 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 fs from "node:fs";
 import net from "node:net";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { BRIDGE_LOG_FILE } from "../wechat/channel-config.js";
+import { BRIDGE_LOG_FILE, getWorkspaceChannelPaths } from "../wechat/channel-config.js";
+import { resolveCodexDaemonControlSocketPath, } from "../bridge/bridge-adapters.codex.js";
 import { ensureWechatCredentials } from "../wechat/setup.js";
 import { ensureWecomAccount } from "../channels/wecom/setup.js";
+import { ensureTelegramAccount } from "../channels/telegram/setup.js";
+import { getBridgeChannelDisplayName, isBridgeChannelId, normalizeBridgeChannelId, } from "../core/channel-types.js";
 import { isDirectModuleRun } from "../core/direct-run.js";
 import { readBridgeLockFile, shouldAutoReclaimBridgeLock, } from "../bridge/bridge-state.js";
 import { clearLocalCompanionOccupancy, clearLocalCompanionEndpoint, readLocalCompanionEndpoint, } from "./local-companion-link.js";
@@ -23,8 +27,8 @@ const MODULE_DIR = path.dirname(MODULE_FILE);
 const RUNTIME_ENTRY_EXTENSION = path.extname(MODULE_FILE) === ".ts" ? ".ts" : ".js";
 const DEFAULT_WAIT_TIMEOUT_MS = 15_000;
 const DEFAULT_ADAPTER = "codex";
-function log(adapter, message, channelId = "wechat") {
-    process.stderr.write(`[${channelId}-${adapter}] ${message}\n`);
+function log(options, message) {
+    process.stderr.write(`[${options.channelId ?? "wechat"}-${options.adapter}] ${message}\n`);
 }
 export function normalizeComparablePath(cwd) {
     const normalized = path.resolve(cwd);
@@ -115,6 +119,8 @@ export function parseCliArgs(argv) {
     let timeoutMs = DEFAULT_WAIT_TIMEOUT_MS;
     let sessionStartMode;
     let channelId = "wechat";
+    let attachCurrentSession = false;
+    let codexThreadId;
     const cliArgs = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -134,15 +140,14 @@ export function parseCliArgs(argv) {
             process.stdout.write([
                 `Usage: ${commandName} [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [--session-start-mode <restore|new>] [...${helpAdapter} args]`,
                 "",
-                `Ensures the ${channelId === "wecom" ? "WeCom" : "WeChat"} runtime for the current directory, then opens or reuses the visible CLI.`,
+                `Ensures the ${getBridgeChannelDisplayName(channelId)} runtime for the current directory, then opens or reuses the visible CLI.`,
                 "If a same-workspace daemon is running, the command delegates to that daemon.",
-                helpAdapter === "codex"
-                    ? "Codex restores the current session by default."
-                    : `${adapterLabel} starts a fresh session by default.`,
-                helpAdapter === "codex"
-                    ? "Use --session-start-mode new to explicitly start a fresh session."
-                    : "Use --session-start-mode restore to explicitly restore the previous session.",
+                `${adapterLabel} starts a fresh session by default.`,
+                "Use --session-start-mode restore to explicitly restore the previous session.",
                 "Use --doctor to check the selected adapter and workspace without starting it.",
+                helpAdapter === "codex"
+                    ? `Use --attach-current-session to attach ${getBridgeChannelDisplayName(channelId)} to the live Codex daemon session in this directory (Codex >= 0.162 shared background server), instead of opening a visible client.`
+                    : "",
                 "Without a daemon, the transient runtime is companion-bound and stops when the visible CLI closes.",
                 "Unknown arguments are forwarded to the visible CLI client.",
                 "",
@@ -153,7 +158,7 @@ export function parseCliArgs(argv) {
             continue;
         }
         if (arg === "--channel") {
-            if (!next || (next !== "wechat" && next !== "wecom")) {
+            if (!isBridgeChannelId(next) || next === "local") {
                 throw new Error(`Invalid channel: ${next ?? "(missing)"}`);
             }
             channelId = next;
@@ -204,8 +209,23 @@ export function parseCliArgs(argv) {
             i += 1;
             continue;
         }
+        if (arg === "--attach-current-session") {
+            attachCurrentSession = true;
+            continue;
+        }
+        if (arg === "--codex-thread-id") {
+            if (!next) {
+                throw new Error("--codex-thread-id requires a value");
+            }
+            codexThreadId = next;
+            i += 1;
+            continue;
+        }
         cliArgs.push(arg);
     }
+    if (attachCurrentSession && adapter !== "codex") {
+        throw new Error("--attach-current-session requires the codex adapter");
+    }
     return {
         adapter,
         cwd,
@@ -214,6 +234,8 @@ export function parseCliArgs(argv) {
         sessionStartMode: sessionStartMode ?? defaultSessionStartMode(adapter),
         cliArgs,
         channelId,
+        attachCurrentSession,
+        codexThreadId,
     };
 }
 function isPidAlive(pid) {
@@ -238,9 +260,9 @@ async function waitForProcessExit(pid, timeoutMs) {
     }
     return !isPidAlive(pid);
 }
-async function stopExistingBridge(lock, requestedAdapter) {
+async function stopExistingBridge(lock, options) {
     const { pid, cwd } = lock;
-    log(requestedAdapter, `Stopping existing bridge for ${cwd} (pid=${pid})...`);
+    log(options, `Stopping existing bridge for ${cwd} (pid=${pid})...`);
     try {
         process.kill(pid);
     }
@@ -264,7 +286,7 @@ async function stopExistingBridge(lock, requestedAdapter) {
     else {
         clearLocalCompanionEndpoint(cwd);
     }
-    log(requestedAdapter, `Cleared stale local companion endpoint for previous workspace ${cwd}.`);
+    log(options, `Cleared stale local companion endpoint for previous workspace ${cwd}.`);
 }
 async function isEndpointReachable(endpoint) {
     await new Promise((resolve) => setTimeout(resolve, 0));
@@ -289,7 +311,8 @@ async function isEndpointReachable(endpoint) {
         socket.once("error", () => finish(false));
     });
 }
-async function readUsableEndpoint(cwd, adapter) {
+async function readUsableEndpoint(options) {
+    const { cwd, adapter } = options;
     const endpoint = readLocalCompanionEndpoint(cwd, { adapter });
     if (!endpoint || endpoint.kind !== adapter) {
         return { endpoint: null };
@@ -298,7 +321,7 @@ async function readUsableEndpoint(cwd, adapter) {
         return { endpoint };
     }
     clearLocalCompanionEndpoint(cwd, endpoint.instanceId, { adapter });
-    log(adapter, `Removed stale local companion endpoint for ${cwd}.`);
+    log(options, `Removed stale local companion endpoint for ${cwd}.`);
     return { endpoint: null };
 }
 function isCompanionAlive(endpoint) {
@@ -314,21 +337,31 @@ function isCompanionAlive(endpoint) {
     return false;
 }
 export function buildBackgroundBridgeArgs(entryPath, options) {
-    const lifecycle = "companion_bound";
+    // The attach bridge outlives this launcher (no visible client keeps the
+    // foreground alive), so it must not be companion-bound to the launcher pid.
+    const lifecycle = options.attachCurrentSession ? "persistent" : "companion_bound";
     const args = ["--no-warnings"];
     if (path.extname(entryPath) === ".ts") {
         args.push("--experimental-strip-types");
     }
     args.push(entryPath, "--adapter", options.adapter, "--cwd", options.cwd, "--lifecycle", lifecycle);
-    if (options.channelId === "wecom") {
-        args.push("--channel", "wecom");
+    if (options.channelId) {
+        args.push("--channel", options.channelId);
     }
-    if (options.sessionStartMode !== "restore") {
-        args.push("--session-start-mode", options.sessionStartMode);
+    // Attach discovery owns thread selection; do not restore stale bridge state.
+    const sessionStartMode = options.attachCurrentSession ? "new" : options.sessionStartMode;
+    if (sessionStartMode !== "restore") {
+        args.push("--session-start-mode", sessionStartMode);
     }
     if (options.profile) {
         args.push("--profile", options.profile);
     }
+    if (options.attachCurrentSession) {
+        args.push("--codex-attach-daemon");
+        if (options.codexThreadId) {
+            args.push("--codex-thread-id", options.codexThreadId);
+        }
+    }
     return args;
 }
 function startBridgeInBackground(options) {
@@ -348,10 +381,11 @@ function startBridgeInBackground(options) {
     });
     child.unref();
 }
-async function waitForEndpoint(cwd, adapter, timeoutMs) {
+async function waitForEndpoint(options) {
+    const { cwd, adapter, timeoutMs } = options;
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        const result = await readUsableEndpoint(cwd, adapter);
+        const result = await readUsableEndpoint(options);
         if (result.endpoint) {
             return result.endpoint;
         }
@@ -361,25 +395,25 @@ async function waitForEndpoint(cwd, adapter, timeoutMs) {
 }
 async function ensureBridgeReady(options) {
     // If the lock is absent or the lock-holding process is dead, do NOT trust a
-    // leftover endpoint.  The bridge (WeChat transport) may have crashed while
+    // leftover endpoint.  The channel transport may have crashed while
     // the opencode server kept running.  Starting only the panel would leave no
-    // bridge to poll WeChat messages.
+    // bridge to receive channel messages.
     const lock = readBridgeLockFile();
     const lockProcessAlive = lock ? isPidAlive(lock.pid) : false;
     if (!lock || !lockProcessAlive) {
         if (lock && !lockProcessAlive) {
-            log(options.adapter, `Found stale lock for ${options.cwd} (pid=${lock.pid} dead). Clearing.`);
+            log(options, `Found stale lock for ${options.cwd} (pid=${lock.pid} dead). Clearing.`);
             clearLocalCompanionEndpoint(options.cwd, undefined, {
                 adapter: options.adapter,
             });
         }
-        log(options.adapter, `Starting bridge in background for ${options.cwd}...`);
+        log(options, `Starting bridge in background for ${options.cwd}...`);
         startBridgeInBackground(options);
-        await waitForEndpoint(options.cwd, options.adapter, options.timeoutMs);
+        await waitForEndpoint(options);
         return { shouldOpenVisibleClient: true };
     }
     // Lock is held by a live process; decide whether to reuse, switch, or replace it.
-    const endpointResult = await readUsableEndpoint(options.cwd, options.adapter);
+    const endpointResult = await readUsableEndpoint(options);
     const decision = decideLaunchAction({
         requestedAdapter: options.adapter,
         requestedCwd: options.cwd,
@@ -391,31 +425,31 @@ async function ensureBridgeReady(options) {
         sessionStartMode: options.sessionStartMode,
         requestedChannelId: options.channelId,
     });
-    log(options.adapter, decision.message);
+    log(options, decision.message);
     if (decision.kind === "already_active") {
         return { shouldOpenVisibleClient: false };
     }
     if (decision.kind === "open_companion") {
         if (!endpointResult.endpoint) {
-            await waitForEndpoint(options.cwd, options.adapter, options.timeoutMs);
+            await waitForEndpoint(options);
         }
         return { shouldOpenVisibleClient: true };
     }
     if (decision.kind === "switch_workspace") {
         try {
-            await stopExistingBridge(lock, options.adapter);
+            await stopExistingBridge(lock, options);
         }
         catch (error) {
-            log(options.adapter, decision.failureMessage);
+            log(options, decision.failureMessage);
             throw error;
         }
     }
     else {
-        await stopExistingBridge(lock, options.adapter);
+        await stopExistingBridge(lock, options);
     }
-    log(options.adapter, `Starting replacement bridge in background for ${options.cwd}...`);
+    log(options, `Starting replacement bridge in background for ${options.cwd}...`);
     startBridgeInBackground(options);
-    await waitForEndpoint(options.cwd, options.adapter, options.timeoutMs);
+    await waitForEndpoint(options);
     return { shouldOpenVisibleClient: true };
 }
 // The daemon's ensure_slot can legitimately take a while: opening a visible
@@ -460,10 +494,10 @@ export async function tryDelegateToDaemon(options, deps = {}) {
         // launch: fall back to a local companion-bound bridge so the user still
         // gets a working terminal instead of an error for work the daemon may
         // still complete.
-        log(options.adapter, `Daemon delegation failed (${response.error ?? "unknown error"}). Falling back to a local bridge.`);
+        log(options, `Daemon delegation failed (${response.error ?? "unknown error"}). Falling back to a local bridge.`);
         return false;
     }
-    log(options.adapter, `Delegated to running ${requestedChannel}-daemon for ${options.cwd}.`, requestedChannel);
+    log(options, `Delegated to running ${requestedChannel}-daemon for ${options.cwd}.`);
     return true;
 }
 export async function runVisibleClient(options, runners = {}) {
@@ -487,17 +521,30 @@ export async function ensureCompanionStartWechatCredentials(adapter, ensureCrede
     await ensureCredentials({
         requireUserId: true,
         validateExisting: true,
-        log: (message) => log(adapter, message),
+        log: (message) => log({ adapter, channelId: "wechat" }, message),
     });
 }
-export async function ensureCompanionStartChannelCredentials(options) {
-    if (options.channelId === "wecom") {
+const channelCredentialSetups = {
+    wechat: async (options) => {
+        await ensureCompanionStartWechatCredentials(options.adapter);
+    },
+    wecom: async (options) => {
         await ensureWecomAccount({
-            log: (message) => log(options.adapter, message, "wecom"),
+            log: (message) => log(options, message),
+        });
+    },
+    telegram: async (options) => {
+        await ensureTelegramAccount({
+            log: (message) => log(options, message),
         });
-        return;
+    },
+};
+export async function ensureCompanionStartChannelCredentials(options) {
+    const channelId = options.channelId ?? "wechat";
+    if (channelId === "local") {
+        throw new Error("The local channel does not support companion launchers.");
     }
-    await ensureCompanionStartWechatCredentials(options.adapter);
+    await channelCredentialSetups[channelId](options);
 }
 export async function runLocalCompanionStart(argv = process.argv.slice(2)) {
     if (argv.includes("--doctor")) {
@@ -507,6 +554,9 @@ export async function runLocalCompanionStart(argv = process.argv.slice(2)) {
     }
     const options = parseCliArgs(argv);
     await ensureCompanionStartChannelCredentials(options);
+    if (options.attachCurrentSession) {
+        return await runAttachCurrentSession(options);
+    }
     if (await tryDelegateToDaemon(options)) {
         return 0;
     }
@@ -516,29 +566,98 @@ export async function runLocalCompanionStart(argv = process.argv.slice(2)) {
     }
     return await runVisibleClient(options);
 }
+export function resolveAttachedBridgeThreadId(state, lock, options) {
+    if (!lock || !state || typeof state !== "object") {
+        return null;
+    }
+    const parsed = state;
+    const channelId = options.channelId ?? "wechat";
+    if (lock.adapter !== "codex" ||
+        !isSameWorkspaceCwd(lock.cwd, options.cwd) ||
+        (lock.channelId ?? "wechat") !== channelId ||
+        parsed.instanceId !== lock.instanceId ||
+        parsed.adapter !== "codex" ||
+        typeof parsed.cwd !== "string" ||
+        !isSameWorkspaceCwd(parsed.cwd, options.cwd) ||
+        (parsed.channelId ?? "wechat") !== channelId ||
+        typeof parsed.sharedThreadId !== "string" ||
+        !parsed.sharedThreadId ||
+        (options.codexThreadId && parsed.sharedThreadId !== options.codexThreadId)) {
+        return null;
+    }
+    return parsed.sharedThreadId;
+}
+export function formatAttachedBridgeMessage(options, sharedThreadId) {
+    return `Attached Codex daemon thread ${sharedThreadId.slice(0, 8)} for ${options.cwd}. ${getBridgeChannelDisplayName(options.channelId ?? "wechat")} forwarding is active; the visible Codex session keeps running unchanged.`;
+}
+async function waitForAttachedBridgeState(options) {
+    const { cwd, timeoutMs } = options;
+    const stateFile = getWorkspaceChannelPaths(cwd).stateFile;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            const raw = fs.readFileSync(stateFile, "utf8");
+            const parsed = JSON.parse(raw);
+            const lock = readBridgeLockFile();
+            const sharedThreadId = resolveAttachedBridgeThreadId(parsed, lock, options);
+            if (sharedThreadId && lock && isPidAlive(lock.pid)) {
+                return { sharedThreadId };
+            }
+        }
+        catch {
+            // Not written yet; keep polling until the deadline.
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    throw new Error(`Timed out waiting for the attach bridge to bind a Codex thread for ${cwd}. Check ${BRIDGE_LOG_FILE}.`);
+}
+/**
+ * Attach flow: bind the selected channel to the live Codex shared-daemon session in the
+ * workspace. No visible client is opened — the owning Codex TUI stays as-is —
+ * so readiness is the persisted bridge state carrying the attached thread id.
+ */
+async function runAttachCurrentSession(options) {
+    const daemonEndpoint = readDaemonEndpoint();
+    if (daemonEndpoint && (await isDaemonEndpointAlive(daemonEndpoint))) {
+        const channel = daemonEndpoint.channelId ?? "wechat";
+        throw new Error(`A ${channel}-daemon is running for ${daemonEndpoint.cwd}. Attach mode needs the workspace bridge lock; stop the daemon first or use its slots.`);
+    }
+    const socketPath = resolveCodexDaemonControlSocketPath();
+    if (!fs.existsSync(socketPath)) {
+        throw new Error(`No shared Codex app-server daemon socket at ${socketPath}. Attach mode requires Codex >= 0.162 with its shared background server (the default). Sessions started with --no-daemon, --oss, or a --profile, and desktop-app embedded sessions, cannot be attached.`);
+    }
+    const lock = readBridgeLockFile();
+    if (lock) {
+        if (isPidAlive(lock.pid)) {
+            await stopExistingBridge(lock, options);
+        }
+        else {
+            clearLocalCompanionEndpoint(options.cwd, undefined, { adapter: options.adapter });
+            log(options, `Cleared stale bridge lock and endpoint for ${lock.cwd}.`);
+        }
+    }
+    log(options, `Starting attach bridge in background for ${options.cwd}...`);
+    startBridgeInBackground(options);
+    const state = await waitForAttachedBridgeState(options);
+    log(options, formatAttachedBridgeMessage(options, state.sharedThreadId));
+    return 0;
+}
 export async function main(argv = process.argv.slice(2)) {
     try {
         const exitCode = await runLocalCompanionStart(argv);
         process.exit(exitCode);
     }
     catch (error) {
-        const adapter = (() => {
-            try {
-                return parseCliArgs(argv).adapter;
-            }
-            catch {
-                return DEFAULT_ADAPTER;
-            }
-        })();
-        const channelId = (() => {
-            try {
-                return parseCliArgs(argv).channelId ?? "wechat";
-            }
-            catch {
-                return "wechat";
-            }
-        })();
-        log(adapter, error instanceof Error ? error.message : String(error), channelId);
+        // Argument validation may fail; retain the wrapper's channel and adapter
+        // without running the failing parser again.
+        const adapterIndex = argv.lastIndexOf("--adapter");
+        const adapterValue = adapterIndex >= 0 ? argv[adapterIndex + 1] : undefined;
+        const adapter = adapterValue && ["codex", "claude", "opencode", "pi"].includes(adapterValue)
+            ? adapterValue
+            : DEFAULT_ADAPTER;
+        const channelIndex = argv.lastIndexOf("--channel");
+        const channelId = normalizeBridgeChannelId(channelIndex >= 0 ? argv[channelIndex + 1] : undefined);
+        log({ adapter, channelId }, error instanceof Error ? error.message : String(error));
         process.exit(1);
     }
 }

package/dist/companion/local-companion.js

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

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

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

package/dist/core/bridge-control.js

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

package/dist/core/bridge-defer.js

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

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

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

package/dist/core/channel-types.js

@@ -1,3 +1,15 @@
+export const BRIDGE_CHANNEL_DISPLAY_NAMES = {
+    wechat: "WeChat",
+    wecom: "WeCom",
+    telegram: "Telegram",
+    local: "Local",
+};
+export function isBridgeChannelId(value) {
+    return typeof value === "string" && Object.hasOwn(BRIDGE_CHANNEL_DISPLAY_NAMES, value);
+}
+export function getBridgeChannelDisplayName(channelId) {
+    return BRIDGE_CHANNEL_DISPLAY_NAMES[channelId];
+}
 export function normalizeBridgeChannelId(value) {
-    return value === "wecom" ? "wecom" : "wechat";
+    return isBridgeChannelId(value) ? value : "wechat";
 }