@unlinearity/cli-wechat-bridge 1.2.0 → 1.2.1

package/README.md

@@ -53,10 +53,11 @@
 
 - [Node.js](https://nodejs.org/en/download) `>= 22.13.0`（建议直接安装官网 LTS 版本）
 - 已安装以下任意一种本地 CLI，并尽量保持最新版本：
-  - [Codex](https://github.com/openai/codex)
+  - [Codex](https://github.com/openai/codex)（已验证 `0.149.x`–`0.157.x`）
   - [Claude Code](https://code.claude.com/docs/en/overview)
-  - [OpenCode](https://github.com/anomalyco/opencode) `>= 1.18.0 < 2.0.0`
-  - [Pi](https://github.com/earendil-works/pi)（已验证 `0.84.2`；需要本机可执行 `pi` 命令）
+  - [OpenCode](https://github.com/anomalyco/opencode)（同时支持 `1.18.x` 与 `2.0.x`）
+  - [Pi](https://github.com/earendil-works/pi)（已验证 `0.85.1`；需要本机可执行 `pi` 命令）
+- Bridge 仅调用安装在 `PATH` 中、可直接执行的独立 CLI；不会发现或调用 ChatGPT.app 等桌面应用内部捆绑的私有可执行文件。
 - 已准备一个远程通道：个人微信使用 `wechat-setup`，企业微信使用 `wecom-setup`
 
 ### 2. 安装与更新

package/dist/bridge/bridge-adapters.codex.js

@@ -12,10 +12,11 @@ import { detectCliApproval, } from "./bridge-utils.js";
 import { normalizeOutput, nowIso, summarizeOutput, truncatePreview, } from "../core/text-utils.js";
 import { AbstractPtyAdapter } from "./bridge-adapters.core.js";
 import { killProcessTreeSync } from "./bridge-process-reaper.js";
+import { CodexVisibleThreadProxy } from "./codex-visible-thread-proxy.js";
 import * as shared from "./bridge-adapters.shared.js";
 import { requestCodexVisibleClientShutdown, requestCodexVisibleThreadSwitch, } from "../companion/codex-visible-client-link.js";
 import { readLocalCompanionEndpoint } from "../companion/local-companion-link.js";
-import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
+import { appendBoundedLog as appendBridgeLog, BRIDGE_LOG_FILE, ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
 import { CODEX_REMOTE_AUTH_TOKEN_ENV, LOCAL_CLIENT_PROTOCOL_VERSION, } from "../runtime/runtime-types.js";
 export function parseCodexCliVersion(output) {
     const match = output.match(/\b(\d+\.\d+\.\d+)\b/);
@@ -28,7 +29,7 @@ export function isCodexVersionInCompatibilityRange(version) {
     }
     const major = parts[0] ?? -1;
     const minor = parts[1] ?? -1;
-    return major === 0 && minor >= 149 && minor <= 155;
+    return major === 0 && minor >= 149 && minor <= 157;
 }
 const { CODEX_APP_SERVER_HOST, CODEX_APP_SERVER_READY_TIMEOUT_MS, CODEX_FINAL_REPLY_SETTLE_DELAY_MS, CODEX_RECENT_SESSION_KEY_LIMIT, CODEX_RPC_CONNECT_RETRY_MS, CODEX_RPC_RECONNECT_TIMEOUT_MS, CODEX_SESSION_FALLBACK_SCAN_INTERVAL_MS, CODEX_SESSION_LOCAL_MIRROR_FALLBACK_WINDOW_MS, CODEX_SESSION_POLL_INTERVAL_MS, CODEX_STARTUP_WARMUP_MS, CODEX_THREAD_SIGNAL_TTL_MS, INTERRUPT_SETTLE_DELAY_MS, appendBoundedLog, buildCodexApprovalRequest, buildCodexCliArgs, buildCodexDynamicToolCallFailureResponse, buildCodexMcpServerElicitationDeclineResponse, buildCodexPermissionsRequestApprovalResponse, buildCodexUserInputRequest, coerceWebSocketMessageData, delay, describeUnknownError, extractCodexFinalTextFromItem, extractCodexThreadFollowIdFromStatusChanged, extractCodexThreadStartedThreadId, extractCodexUserMessageText, findCodexSessionFile, findRecentCodexSessionFileForCwd, getCodexRpcRequestId, getCodexApprovalAutoResponse, getCodexWechatOutboundAttachmentDenyMessage, getNotificationThreadId, getNotificationTurnId, isRecord, isRecentIsoTimestamp, listCodexResumeSessions, normalizeComparablePath, normalizeCodexRpcError, reserveLocalPort, resolveSpawnTarget, shouldAutoCompleteCodexWechatTurnAfterFinalReply, shouldIgnoreCodexSessionReplayEntry, shouldRecoverCodexStaleBusyState, waitForTcpPort, } = shared;
 const CODEX_LOCAL_THREAD_ANNOUNCE_SETTLE_MS = 150;
@@ -80,6 +81,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     appServer = null;
     nativeProcess = null;
     appServerPort = null;
+    visibleThreadProxy = null;
+    visibleOutOfWorkspaceThreadId = null;
     appServerShuttingDown = false;
     appServerLog = "";
     appServerAuthToken = null;
@@ -166,8 +169,18 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.setStatus("starting", `Codex protocol compatibility: ${compatibility}.`);
         await this.startAppServer();
         await this.connectRpcClient();
-        await this.restoreInitialSharedThreadIfNeeded();
         try {
+            if (this.isHeadlessRuntimeMode() && this.appServerPort && this.appServerAuthToken) {
+                const trace = (message) => appendBridgeLog(BRIDGE_LOG_FILE, `[${nowIso()}] codex_visible_proxy: ${message}\n`);
+                this.visibleThreadProxy = await CodexVisibleThreadProxy.start({
+                    upstreamUrl: `ws://${CODEX_APP_SERVER_HOST}:${this.appServerPort}`,
+                    token: this.appServerAuthToken,
+                    onTrace: trace,
+                    onThreadOpened: (threadId, cwd) => this.handleVisibleCodexThreadOpened(threadId, cwd, trace),
+                    onVisibleTurn: (threadId) => this.handleVisibleCodexTurn(threadId, trace),
+                });
+            }
+            await this.restoreInitialSharedThreadIfNeeded();
             if (this.isNativePanelMode()) {
                 await this.startNativeClient();
             }
@@ -286,6 +299,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         return models;
     }
     async selectModel(modelId) {
+        this.assertVisibleCodexWorkspace();
         const models = await this.listModels();
         const selected = models.find((model) => model.id === modelId);
         if (!selected)
@@ -294,6 +308,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         return selected;
     }
     async setPlanMode(enabled) {
+        this.assertVisibleCodexWorkspace();
         if (!this.usesRpcTurnTransport() || !this.sharedThreadId) {
             throw new Error("Codex plan mode requires an active app-server thread.");
         }
@@ -464,7 +479,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             renderMode: "headless",
             bridgeOwnerPid: process.pid,
             serverPort: this.appServerPort,
-            serverUrl: `ws://${CODEX_APP_SERVER_HOST}:${this.appServerPort}`,
+            serverUrl: this.visibleThreadProxy?.url ?? `ws://${CODEX_APP_SERVER_HOST}:${this.appServerPort}`,
             remoteAuthTokenEnv: CODEX_REMOTE_AUTH_TOKEN_ENV,
             cwd: this.options.cwd,
             command: this.options.command,
@@ -1020,6 +1035,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
     }
     async sendPanelTurn(text) {
+        this.assertVisibleCodexWorkspace();
         if (this.isNativePanelMode() && !this.nativeProcess) {
             throw new Error("codex panel is not running.");
         }
@@ -1168,6 +1184,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             });
             this.appServer = null;
             this.appServerPort = null;
+            void this.visibleThreadProxy?.close();
+            this.visibleThreadProxy = null;
             this.appServerShuttingDown = false;
             this.deleteAppServerAuthTokenFile();
             this.appServerAuthToken = null;
@@ -1190,6 +1208,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             });
             this.appServer = null;
             this.appServerPort = null;
+            void this.visibleThreadProxy?.close();
+            this.visibleThreadProxy = null;
             this.appServerShuttingDown = false;
             this.deleteAppServerAuthTokenFile();
             this.appServerAuthToken = null;
@@ -1660,6 +1680,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 reason: "wechat_resume",
                 notify: true,
             });
+            this.clearVisibleCodexWorkspaceBlock();
             this.bridgeResumeReplayThreadId = targetThreadId;
             this.bridgeResumeReplayUntilMs = Date.now() + CODEX_RESUME_REPLAY_SETTLE_MS;
             this.setStatus("starting", `Codex resume committed thread ${targetThreadId.slice(0, 12)}.`);
@@ -1881,6 +1902,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!options.preserveThread) {
             this.clearPendingThreadAnnouncement();
             this.announcedThreadId = null;
+            this.visibleOutOfWorkspaceThreadId = null;
         }
         if (!options.preserveThread) {
             this.updateSharedThread(null);
@@ -2000,6 +2022,62 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }, CODEX_LOCAL_THREAD_ANNOUNCE_SETTLE_MS);
         pending.timer.unref?.();
     }
+    handleVisibleCodexThreadOpened(threadId, cwd, trace) {
+        if (this.pendingVisibleResume || this.shuttingDown) {
+            trace?.(`ignored thread=${threadId.slice(0, 12)} reason=bridge_switch`);
+            return;
+        }
+        if (cwd && normalizeComparablePath(cwd) !== normalizeComparablePath(this.options.cwd)) {
+            trace?.(`paused thread=${threadId.slice(0, 12)} reason=workspace`);
+            this.interruptWechatTurnForLocalThreadSwitch(threadId);
+            this.clearPendingThreadAnnouncement();
+            this.pendingThreadFollowId = null;
+            if (this.visibleOutOfWorkspaceThreadId !== threadId) {
+                this.visibleOutOfWorkspaceThreadId = threadId;
+                this.emit({
+                    type: "notice",
+                    level: "warning",
+                    text: `The visible Codex terminal switched to ${cwd}, outside the bridge workspace ${this.options.cwd}. WeChat input is paused instead of being sent to the previous session. Resume a session from the bridge workspace, or restart the bridge in ${cwd}.`,
+                    timestamp: nowIso(),
+                });
+            }
+            return;
+        }
+        this.clearVisibleCodexWorkspaceBlock();
+        trace?.(`follow thread=${threadId.slice(0, 12)} source=visible_open`);
+        this.trackLocalSharedThread(threadId, { reason: "local_follow", signal: "visible_request" });
+    }
+    handleVisibleCodexTurn(threadId, trace) {
+        if (this.pendingVisibleResume || this.shuttingDown)
+            return;
+        if (threadId === this.sharedThreadId) {
+            this.clearVisibleCodexWorkspaceBlock();
+            return;
+        }
+        if (!findCodexSessionFile(this.options.cwd, Date.now(), { threadId })) {
+            trace?.(`ignored thread=${threadId.slice(0, 12)} reason=workspace_or_unpersisted`);
+            return;
+        }
+        this.clearVisibleCodexWorkspaceBlock();
+        trace?.(`follow thread=${threadId.slice(0, 12)} source=visible_turn`);
+        this.trackLocalSharedThread(threadId, { reason: "local_follow", signal: "visible_request" });
+    }
+    clearVisibleCodexWorkspaceBlock() {
+        if (!this.visibleOutOfWorkspaceThreadId)
+            return;
+        this.visibleOutOfWorkspaceThreadId = null;
+        this.emit({
+            type: "notice",
+            level: "info",
+            text: `The visible Codex terminal is back in the bridge workspace ${this.options.cwd}. WeChat input has resumed.`,
+            timestamp: nowIso(),
+        });
+    }
+    assertVisibleCodexWorkspace() {
+        if (this.visibleOutOfWorkspaceThreadId) {
+            throw new Error(`The visible Codex terminal is outside the bridge workspace ${this.options.cwd}. WeChat input is paused; resume a session from this workspace or restart the bridge in the terminal's workspace.`);
+        }
+    }
     trackLocalSharedThread(threadId, options) {
         const weakSignal = options.signal === "status_changed" ||
             options.signal === "thread_started" ||
@@ -2007,7 +2085,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (weakSignal && Date.now() < this.localThreadFollowBlockedUntilMs) {
             return;
         }
-        if (options.signal === "user_message" || options.signal === "turn_started") {
+        if (options.signal === "user_message" || options.signal === "turn_started" || options.signal === "visible_request") {
             this.localThreadFollowBlockedUntilMs = 0;
         }
         if (this.pendingVisibleResume) {
@@ -2343,7 +2421,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 origin: "local",
             };
         }
-        if (method === "turn/started" && !this.activeTurn) {
+        if (method === "turn/started" && !this.activeTurn && !this.visibleThreadProxy) {
             return {
                 threadId,
                 turnId,
@@ -2617,7 +2695,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!threadId) {
             return;
         }
-        if (this.pendingVisibleResume) {
+        if (this.pendingVisibleResume || this.visibleThreadProxy) {
             return;
         }
         if (this.isBridgeResumeReplay(threadId)) {
@@ -2696,7 +2774,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!threadId) {
             return;
         }
-        if (this.isBridgeResumeReplay(threadId)) {
+        if (this.visibleThreadProxy || this.isBridgeResumeReplay(threadId)) {
             return;
         }
         if (this.isRecentlyBridgeOwnedThread(threadId)) {
@@ -2974,6 +3052,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.rememberCompletedTurn(turnId);
     }
     async stopAppServer() {
+        const visibleThreadProxy = this.visibleThreadProxy;
+        this.visibleThreadProxy = null;
+        await visibleThreadProxy?.close();
         if (!this.appServer) {
             this.appServerPort = null;
             this.appServerShuttingDown = false;

package/dist/bridge/bridge-adapters.opencode.js

@@ -12,6 +12,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { OPENCODE_SERVER_HOST, OPENCODE_SERVER_READY_TIMEOUT_MS, OPENCODE_SSE_RECONNECT_DELAY_MS, OPENCODE_SESSION_IDLE_SETTLE_MS, OPENCODE_WECHAT_WORKING_NOTICE_DELAY_MS, OPENCODE_HTTP_READY_TIMEOUT_MS, OPENCODE_HTTP_READY_PROBE_TIMEOUT_MS, OPENCODE_HTTP_READY_PROBE_INTERVAL_MS, buildCliEnvironment, isRecord, describeUnknownError, resolveSpawnTarget, reserveLocalPort, waitForTcpPort, delay, } from "./bridge-adapters.shared.js";
 import { killProcessTreeSync } from "./bridge-process-reaper.js";
+import { createOpenCodeV2CompatClient } from "./opencode-v2-compat.js";
 import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
 import { WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE, buildOneTimeCode, isWechatOutboundAttachmentMutationTool, isWechatOutboundAttachmentWriteCommand, normalizeOutput, nowIso, truncatePreview, OutputBatcher, } from "./bridge-utils.js";
 const OPENCODE_DEBUG_ENABLED = /^(1|true|yes|on)$/i.test(process.env.WECHAT_OPENCODE_DEBUG ?? "");
@@ -24,7 +25,11 @@ const TUI_SESSION_SELECT_SUPPRESSION_TTL_MS = 5_000;
 const OPENCODE_LOCAL_SESSION_CREATE_FOLLOW_TTL_MS = 5_000;
 const OPENCODE_TUI_SELECT_RETRY_DELAYS_MS = [250, 750, 1_500];
 const OPENCODE_MINIMUM_SUPPORTED_VERSION = "1.18.0";
-const OPENCODE_MAXIMUM_SUPPORTED_MAJOR = 2;
+const OPENCODE_MAXIMUM_SUPPORTED_MAJOR = 3;
+const OPENCODE_VERSION_PROBE_TIMEOUT_MS = 5_000;
+export function parseOpenCodeCliVersion(output) {
+    return /\bv?(\d+\.\d+\.\d+)\b/.exec(output)?.[1] ?? null;
+}
 const OPENCODE_TUI_ROUTE_READY_TIMEOUT_MS = 10_000;
 const OPENCODE_TUI_ROUTE_MAX_BUFFER_SIZE = 1024 * 1024;
 const MODULE_FILE = fileURLToPath(import.meta.url);
@@ -83,6 +88,8 @@ export class OpenCodeServerAdapter {
     tuiRoutePort = 0;
     tuiRouteConfigDir = null;
     tuiRouteConfigPath = null;
+    tuiRoutePluginPath = null;
+    openCodeMajor = 1;
     visibleTuiSessionId = null;
     tuiRouteStateReceived = false;
     expectedVisibleTuiSessionId = null;
@@ -250,6 +257,7 @@ export class OpenCodeServerAdapter {
         this.shuttingDown = false;
         this.setStatus("starting", "Starting OpenCode companion...");
         try {
+            await this.probeOpenCodeVersion();
             this.serverPort = await reserveLocalPort();
             const serverProcess = await this.startServerProcess();
             await waitForTcpPort(OPENCODE_SERVER_HOST, this.serverPort, OPENCODE_SERVER_READY_TIMEOUT_MS);
@@ -632,13 +640,28 @@ export class OpenCodeServerAdapter {
                 resolve(address.port);
             });
         });
-        const workspaceDir = ensureWorkspaceChannelDir(this.options.cwd).workspaceDir;
-        const configDir = fs.mkdtempSync(path.join(workspaceDir, "opencode-tui-route-"));
-        const configPath = path.join(configDir, "tui.json");
-        const pluginPath = path.join(MODULE_DIR, "..", "companion", `opencode-tui-bridge-plugin${RUNTIME_ENTRY_EXTENSION}`);
+        const pluginName = this.openCodeMajor >= 2
+            ? "opencode-v2-tui-bridge-plugin"
+            : "opencode-tui-bridge-plugin";
+        const pluginPath = path.join(MODULE_DIR, "..", "companion", `${pluginName}${RUNTIME_ENTRY_EXTENSION}`);
         if (!fs.existsSync(pluginPath)) {
             throw new Error(`OpenCode TUI bridge plugin was not found: ${pluginPath}`);
         }
+        const workspaceDir = ensureWorkspaceChannelDir(this.options.cwd).workspaceDir;
+        const configDir = fs.mkdtempSync(path.join(workspaceDir, "opencode-tui-route-"));
+        this.tuiRouteConfigDir = configDir;
+        if (this.openCodeMajor >= 2) {
+            fs.copyFileSync(pluginPath, path.join(configDir, `tui${RUNTIME_ENTRY_EXTENSION}`));
+            fs.writeFileSync(path.join(configDir, "package.json"), `${JSON.stringify({
+                name: "cli-wechat-bridge-opencode-tui-route",
+                private: true,
+                type: "module",
+            }, null, 2)}\n`, "utf8");
+            this.tuiRoutePluginPath = configDir;
+            return;
+        }
+        this.tuiRoutePluginPath = pluginPath;
+        const configPath = path.join(configDir, "tui.json");
         fs.writeFileSync(configPath, `${JSON.stringify({
             plugin: [
                 [
@@ -650,7 +673,6 @@ export class OpenCodeServerAdapter {
                 ],
             ],
         }, null, 2)}\n`, "utf8");
-        this.tuiRouteConfigDir = configDir;
         this.tuiRouteConfigPath = configPath;
     }
     acceptTuiRouteSocket(socket) {
@@ -765,6 +787,7 @@ export class OpenCodeServerAdapter {
         const configDir = this.tuiRouteConfigDir;
         this.tuiRouteConfigDir = null;
         this.tuiRouteConfigPath = null;
+        this.tuiRoutePluginPath = null;
         this.tuiRoutePort = 0;
         this.tuiRouteToken = "";
         this.tuiRouteStateReceived = false;
@@ -781,6 +804,50 @@ export class OpenCodeServerAdapter {
             }
         }
     }
+    async probeOpenCodeVersion() {
+        const env = buildCliEnvironment(this.options.kind);
+        const target = resolveSpawnTarget(this.options.command, this.options.kind, { env });
+        const version = await new Promise((resolve, reject) => {
+            const child = spawnChildProcess(target.file, [...target.args, "--version"], {
+                cwd: this.options.cwd,
+                env,
+                stdio: ["ignore", "pipe", "pipe"],
+                windowsHide: true,
+            });
+            let output = "";
+            let settled = false;
+            const finish = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                if (error)
+                    reject(error);
+                else
+                    resolve(output);
+            };
+            const timer = setTimeout(() => {
+                if (child.pid != null) {
+                    killProcessTreeSync(child.pid);
+                }
+                finish(new Error("Timed out checking the OpenCode CLI version."));
+            }, OPENCODE_VERSION_PROBE_TIMEOUT_MS);
+            child.stdout?.on("data", (chunk) => { output += chunk.toString("utf8"); });
+            child.stderr?.on("data", (chunk) => { output += chunk.toString("utf8"); });
+            child.once("error", (error) => finish(error));
+            child.once("exit", (code) => {
+                if (code === 0)
+                    finish();
+                else
+                    finish(new Error(`OpenCode --version exited with code ${code ?? "unknown"}.`));
+            });
+        });
+        const parsed = parseOpenCodeCliVersion(version);
+        if (!parsed || !this.isSupportedOpenCodeVersion(parsed)) {
+            throw new Error(`Unsupported OpenCode version ${parsed ?? (version.trim() || "unknown")}. Install OpenCode >=${OPENCODE_MINIMUM_SUPPORTED_VERSION} <${OPENCODE_MAXIMUM_SUPPORTED_MAJOR}.0.0.`);
+        }
+        this.openCodeMajor = Number(parsed.split(".")[0]);
+    }
     async startServerProcess() {
         const env = buildCliEnvironment(this.options.kind);
         this.serverPassword = randomBytes(24).toString("hex");
@@ -886,8 +953,9 @@ export class OpenCodeServerAdapter {
         if ((this.options.extraCliArgs ?? []).includes("--pure")) {
             throw new Error("OpenCode --pure cannot be used with the WeChat bridge because local session following requires the managed TUI plugin.");
         }
-        const args = ["attach", this.getServerUrl()];
-        args.push("--dir", this.options.cwd);
+        const args = this.openCodeMajor >= 2
+            ? ["--server", this.getServerUrl()]
+            : ["attach", this.getServerUrl(), "--dir", this.options.cwd];
         const sessionId = this.activeSessionId;
         if (sessionId && (await this.hasSession(sessionId))) {
             args.push("--session", sessionId);
@@ -897,7 +965,37 @@ export class OpenCodeServerAdapter {
     }
     buildNativeClientEnv() {
         const env = buildCliEnvironment(this.options.kind);
-        if (this.tuiRouteConfigDir && this.tuiRouteConfigPath) {
+        if (this.openCodeMajor >= 2 && this.tuiRoutePluginPath) {
+            let existingConfig = {};
+            if (env.OPENCODE_CLI_CONFIG_CONTENT) {
+                try {
+                    const parsed = JSON.parse(env.OPENCODE_CLI_CONFIG_CONTENT);
+                    if (isRecord(parsed))
+                        existingConfig = parsed;
+                }
+                catch (error) {
+                    throw new Error(`OpenCode cannot merge the managed TUI plugin into invalid OPENCODE_CLI_CONFIG_CONTENT: ${describeUnknownError(error)}`, { cause: error });
+                }
+            }
+            const existingPlugins = Array.isArray(existingConfig.plugins)
+                ? existingConfig.plugins
+                : [];
+            env.OPENCODE_CLI_CONFIG_CONTENT = JSON.stringify({
+                ...existingConfig,
+                plugins: [
+                    ...existingPlugins,
+                    {
+                        package: this.tuiRoutePluginPath,
+                        options: {
+                            port: this.tuiRoutePort,
+                            token: this.tuiRouteToken,
+                        },
+                    },
+                ],
+            });
+            env.OPENCODE_PASSWORD = this.serverPassword ?? "";
+        }
+        else if (this.tuiRouteConfigDir && this.tuiRouteConfigPath) {
             if (env.OPENCODE_CONFIG_DIR && env.OPENCODE_TUI_CONFIG) {
                 throw new Error("OpenCode cannot inject the managed TUI session plugin while both OPENCODE_CONFIG_DIR and OPENCODE_TUI_CONFIG are set.");
             }
@@ -911,7 +1009,7 @@ export class OpenCodeServerAdapter {
         if (this.serverPassword) {
             env.OPENCODE_SERVER_PASSWORD = this.serverPassword;
         }
-        if (this.activeSessionId) {
+        if (this.activeSessionId && this.openCodeMajor < 2) {
             env.OPENCODE_ROUTE = JSON.stringify({
                 type: "session",
                 sessionID: this.activeSessionId,
@@ -928,6 +1026,14 @@ export class OpenCodeServerAdapter {
     }
     async createSdkClient() {
         try {
+            if (this.openCodeMajor >= 2) {
+                this.client = await createOpenCodeV2CompatClient({
+                    baseUrl: `http://${OPENCODE_SERVER_HOST}:${this.serverPort}`,
+                    directory: this.options.cwd,
+                    headers: this.buildServerAuthHeaders(),
+                });
+                return;
+            }
             const { createOpencodeClient } = await import("@opencode-ai/sdk/v2");
             this.client = createOpencodeClient({
                 baseUrl: `http://${OPENCODE_SERVER_HOST}:${this.serverPort}`,
@@ -937,7 +1043,8 @@ export class OpenCodeServerAdapter {
             });
         }
         catch (err) {
-            throw new Error(`Failed to load @opencode-ai/sdk. Make sure it is installed: ${describeUnknownError(err)}`, { cause: err });
+            const packageName = this.openCodeMajor >= 2 ? "@opencode/client" : "@opencode-ai/sdk";
+            throw new Error(`Failed to load ${packageName}. Make sure it is installed: ${describeUnknownError(err)}`, { cause: err });
         }
     }
     async checkHealth() {
@@ -952,17 +1059,24 @@ export class OpenCodeServerAdapter {
         let lastError;
         while (Date.now() < deadline) {
             try {
-                const response = await fetch(`${baseUrl}/global/health`, {
+                const healthPath = this.openCodeMajor >= 2 ? "/api/info" : "/global/health";
+                const response = await fetch(`${baseUrl}${healthPath}`, {
                     headers: this.buildServerAuthHeaders(),
                     signal: AbortSignal.timeout(OPENCODE_HTTP_READY_PROBE_TIMEOUT_MS),
                 });
                 if (response.ok) {
                     const health = await response.json();
-                    if (!isRecord(health) || health.healthy !== true || typeof health.version !== "string") {
+                    const version = isRecord(health) && typeof health.version === "string"
+                        ? health.version
+                        : undefined;
+                    const healthy = this.openCodeMajor >= 2
+                        ? Boolean(version)
+                        : isRecord(health) && health.healthy === true;
+                    if (!healthy || !version) {
                         lastError = new Error("OpenCode health check returned an invalid response.");
                     }
-                    else if (!this.isSupportedOpenCodeVersion(health.version)) {
-                        throw new Error(`Unsupported OpenCode version ${health.version}. Install OpenCode >=${OPENCODE_MINIMUM_SUPPORTED_VERSION} <${OPENCODE_MAXIMUM_SUPPORTED_MAJOR}.0.0.`);
+                    else if (!this.isSupportedOpenCodeVersion(version)) {
+                        throw new Error(`Unsupported OpenCode version ${version}. Install OpenCode >=${OPENCODE_MINIMUM_SUPPORTED_VERSION} <${OPENCODE_MAXIMUM_SUPPORTED_MAJOR}.0.0.`);
                     }
                     else {
                         return;
@@ -1099,10 +1213,9 @@ export class OpenCodeServerAdapter {
             return;
         }
         this.sseAbortController = new AbortController();
-        const sseLoops = [
-            this.runSseLoop("event"),
-            this.runSseLoop("global-event"),
-        ];
+        const sseLoops = this.openCodeMajor >= 2
+            ? [this.runSseLoop("event")]
+            : [this.runSseLoop("event"), this.runSseLoop("global-event")];
         this.sseLoopPromise = Promise.all(sseLoops).then(() => undefined);
     }
     async runSseLoop(streamName) {
@@ -2745,6 +2858,16 @@ export class OpenCodeServerAdapter {
         }
     }
     async sendVisibleSessionSelection(session) {
+        if (this.openCodeMajor >= 2) {
+            if (!this.tuiRouteSocket || this.tuiRouteSocket.destroyed) {
+                throw new Error("The OpenCode 2 TUI route bridge is not connected.");
+            }
+            this.tuiRouteSocket.write(`${JSON.stringify({
+                type: "select_session",
+                sessionId: session.id,
+            })}\n`);
+            return;
+        }
         if (!this.client?.tui) {
             return;
         }

package/dist/bridge/claude-native-controls.js

@@ -1,4 +1,4 @@
-import { NativeTerminalControl, parseClaudeModelPicker, readClaudePermissionMode } from "./native-terminal-control.js";
+import { NativeTerminalControl, parseClaudeModelPicker, parseClaudeModelSwitchConfirmation, readClaudePermissionMode } from "./native-terminal-control.js";
 export class ClaudeNativeControls {
     previousMode = null;
     terminal;
@@ -83,7 +83,19 @@ export class ClaudeNativeControls {
                 throw new Error("This Claude version does not expose session-only model selection. Update Claude Code and try again.");
             }
             await this.terminal.submitMenu(undefined, "s");
-            await this.terminal.waitFor(() => readClaudePermissionMode(this.terminal.text) !== null);
+            await this.terminal.waitFor(() => parseClaudeModelSwitchConfirmation(this.terminal.text) !== null || readClaudePermissionMode(this.terminal.text) !== null);
+            const confirmation = parseClaudeModelSwitchConfirmation(this.terminal.text);
+            if (confirmation) {
+                const targetLabel = target.label.toLowerCase();
+                const confirmedModel = confirmation.model.toLowerCase();
+                const matchesTarget = targetLabel.includes(confirmedModel)
+                    || (targetLabel.startsWith("default (recommended)") && confirmedModel.endsWith(" (default)"));
+                if (!confirmation.yesFocused || !matchesTarget) {
+                    throw new Error("Claude displayed an unexpected model switch confirmation. Check the visible terminal before trying again.");
+                }
+                await this.terminal.key("\r");
+                await this.terminal.waitFor(() => readClaudePermissionMode(this.terminal.text) !== null);
+            }
             await this.terminal.openMenu("/model", "Select model");
             const applied = parseClaudeModelPicker(this.terminal.text).find((row) => row.focused);
             if (!applied || applied.label !== target.label || applied.index !== target.index)

package/dist/bridge/codex-visible-thread-proxy.js

@@ -0,0 +1,140 @@
+import { WebSocket, WebSocketServer } from "ws";
+export class CodexVisibleThreadProxy {
+    server;
+    clients = new Set();
+    upstreams = new Set();
+    constructor(options) {
+        this.server = new WebSocketServer({
+            host: "127.0.0.1",
+            port: 0,
+            verifyClient: ({ req }) => req.headers.authorization === `Bearer ${options.token}`,
+        });
+        this.server.on("connection", (client) => {
+            options.onTrace?.("client_connected");
+            const upstream = new WebSocket(options.upstreamUrl, {
+                headers: { Authorization: `Bearer ${options.token}` },
+            });
+            this.clients.add(client);
+            this.upstreams.add(upstream);
+            const pendingRequests = new Map();
+            const queued = [];
+            let queuedBytes = 0;
+            client.on("message", (data, binary) => {
+                const bytes = Buffer.from(data);
+                if (!binary) {
+                    try {
+                        const request = JSON.parse(bytes.toString("utf8"));
+                        if (request && typeof request === "object" && "method" in request) {
+                            if (typeof request.method === "string" &&
+                                (request.method.startsWith("thread/") || request.method === "turn/start")) {
+                                const params = "params" in request && request.params && typeof request.params === "object"
+                                    ? request.params : null;
+                                const threadId = params && "threadId" in params && typeof params.threadId === "string"
+                                    ? params.threadId.slice(0, 12) : "none";
+                                options.onTrace?.(`request method=${request.method} thread=${threadId}`);
+                            }
+                            if (request.method === "turn/start" && "params" in request &&
+                                request.params && typeof request.params === "object" &&
+                                "threadId" in request.params && typeof request.params.threadId === "string") {
+                                options.onVisibleTurn(request.params.threadId);
+                            }
+                            if ((request.method === "thread/resume" || request.method === "thread/start") &&
+                                "id" in request && (typeof request.id === "number" || typeof request.id === "string")) {
+                                pendingRequests.set(request.id, request.method);
+                            }
+                        }
+                    }
+                    catch {
+                        // Forward non-JSON messages unchanged.
+                    }
+                }
+                if (upstream.readyState === WebSocket.OPEN) {
+                    upstream.send(bytes, { binary });
+                }
+                else if (upstream.readyState === WebSocket.CONNECTING && queuedBytes + bytes.length <= 1_048_576) {
+                    queued.push({ data: bytes, binary });
+                    queuedBytes += bytes.length;
+                }
+                else {
+                    client.close();
+                }
+            });
+            upstream.on("open", () => {
+                for (const message of queued)
+                    upstream.send(message.data, { binary: message.binary });
+                queued.length = 0;
+            });
+            upstream.on("message", (data, binary) => {
+                if (!binary) {
+                    try {
+                        const response = JSON.parse(data.toString());
+                        const pendingMethod = response && typeof response === "object" && "id" in response &&
+                            (typeof response.id === "number" || typeof response.id === "string")
+                            ? pendingRequests.get(response.id) : undefined;
+                        if (pendingMethod && response && typeof response === "object" && "id" in response &&
+                            (typeof response.id === "number" || typeof response.id === "string")) {
+                            pendingRequests.delete(response.id);
+                            options.onTrace?.(`response method=${pendingMethod} success=${"result" in response}`);
+                        }
+                        if (pendingMethod && response && typeof response === "object" && "result" in response &&
+                            response.result && typeof response.result === "object" &&
+                            "thread" in response.result && response.result.thread &&
+                            typeof response.result.thread === "object" && "id" in response.result.thread &&
+                            typeof response.result.thread.id === "string" &&
+                            !("parentThreadId" in response.result.thread &&
+                                typeof response.result.thread.parentThreadId === "string") &&
+                            !("ephemeral" in response.result.thread && response.result.thread.ephemeral === true)) {
+                            const cwd = "cwd" in response.result.thread && typeof response.result.thread.cwd === "string"
+                                ? response.result.thread.cwd
+                                : undefined;
+                            options.onTrace?.(`opened thread=${response.result.thread.id.slice(0, 12)} cwd=${cwd ?? "unknown"}`);
+                            options.onThreadOpened(response.result.thread.id, cwd);
+                        }
+                    }
+                    catch {
+                        // A malformed response must not interrupt the visible client.
+                    }
+                }
+                if (client.readyState === WebSocket.OPEN)
+                    client.send(data, { binary });
+            });
+            client.on("close", () => upstream.terminate());
+            upstream.on("close", () => client.close());
+            client.on("error", () => upstream.terminate());
+            upstream.on("error", () => client.close());
+            client.on("close", () => {
+                this.clients.delete(client);
+                options.onTrace?.("client_disconnected");
+            });
+            upstream.on("close", () => this.upstreams.delete(upstream));
+        });
+    }
+    static async start(options) {
+        const proxy = new CodexVisibleThreadProxy(options);
+        try {
+            await new Promise((resolve, reject) => {
+                proxy.server.once("listening", resolve);
+                proxy.server.once("error", reject);
+            });
+            return proxy;
+        }
+        catch (error) {
+            proxy.server.close();
+            throw error;
+        }
+    }
+    get connected() {
+        return this.clients.size > 0;
+    }
+    get url() {
+        const address = this.server.address();
+        return `ws://127.0.0.1:${address.port}`;
+    }
+    async close() {
+        for (const client of this.clients)
+            client.terminate();
+        for (const upstream of this.upstreams)
+            upstream.terminate();
+        await new Promise((resolve) => this.server.close(() => resolve()));
+    }
+}

package/dist/bridge/native-terminal-control.js

@@ -245,6 +245,18 @@ export function parseClaudeModelPicker(text) {
         return [{ index: Number(match[2]), label: match[3].replace(/[✓✔]/g, "").replace(/\s+/g, " ").trim(), current: /[✓✔]/.test(line), focused: /[❯>]/.test(match[1]) }];
     });
 }
+export function parseClaudeModelSwitchConfirmation(text) {
+    const lines = text.split("\n");
+    const start = lines.findLastIndex((line) => line.trim() === "Switch model?");
+    if (start < 0)
+        return null;
+    const choices = lines.slice(start + 1);
+    const yes = choices.map((line) => /^\s*(❯|>)?\s*1\. Yes, switch to (.+?)\s*$/.exec(line)).find((match) => match);
+    const noIndex = choices.findIndex((line) => /^\s*(?:❯|>)?\s*2\. No, go back\s*$/.test(line));
+    if (!yes || noIndex < 0 || choices.slice(noIndex + 1).some((line) => /^\s*❯/.test(line)))
+        return null;
+    return { model: yes[2], yesFocused: Boolean(yes[1]) };
+}
 export function readClaudePermissionMode(text) {
     const lines = text.split("\n");
     const prompt = lines.findLastIndex((line) => /^\s*❯/.test(line));

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

@@ -0,0 +1,450 @@
+// 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.
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function ok(data) {
+    return { data };
+}
+async function result(operation) {
+    try {
+        return ok(await operation());
+    }
+    catch (error) {
+        return { error };
+    }
+}
+function location(directory) {
+    return typeof directory === "string" && directory
+        ? { directory }
+        : undefined;
+}
+export function normalizeOpenCodeV2Session(value) {
+    const session = isRecord(value) ? value : {};
+    const sessionLocation = isRecord(session.location) ? session.location : {};
+    const time = isRecord(session.time) ? session.time : {};
+    const model = isRecord(session.model) ? session.model : undefined;
+    return {
+        ...session,
+        id: typeof session.id === "string" ? session.id : "",
+        directory: typeof sessionLocation.directory === "string"
+            ? sessionLocation.directory
+            : "",
+        workspaceID: typeof session.projectID === "string" ? session.projectID : undefined,
+        parentID: typeof session.parentID === "string" ? session.parentID : undefined,
+        time: {
+            ...time,
+            created: typeof time.created === "number" ? time.created : Date.now(),
+            updated: typeof time.updated === "number" ? time.updated : Date.now(),
+        },
+        model: model
+            ? {
+                ...model,
+                id: typeof model.id === "string" ? model.id : "",
+                providerID: typeof model.providerID === "string" ? model.providerID : "",
+                variant: typeof model.variant === "string" ? model.variant : "default",
+            }
+            : undefined,
+    };
+}
+function sessionFromCreatedEvent(data) {
+    const eventLocation = isRecord(data.location) ? data.location : {};
+    return normalizeOpenCodeV2Session({
+        id: data.sessionID,
+        projectID: data.projectID,
+        parentID: data.parentID,
+        title: data.title,
+        agent: data.agent,
+        model: data.model,
+        location: eventLocation,
+        time: { created: Date.now(), updated: Date.now() },
+    });
+}
+function textPart(data, text) {
+    const ordinal = typeof data.ordinal === "number" ? data.ordinal : 0;
+    return {
+        id: `${String(data.assistantMessageID ?? "message")}:text:${ordinal}`,
+        sessionID: data.sessionID,
+        messageID: data.assistantMessageID,
+        type: "text",
+        ...(text === undefined ? {} : { text }),
+    };
+}
+function normalizeFormQuestions(form) {
+    const fields = Array.isArray(form.fields) ? form.fields : [];
+    return fields.flatMap((field) => {
+        if (!isRecord(field) || typeof field.key !== "string")
+            return [];
+        const configuredOptions = Array.isArray(field.options)
+            ? field.options.filter(isRecord).map((option) => ({
+                label: typeof option.label === "string" ? option.label : String(option.value ?? ""),
+                description: typeof option.description === "string" ? option.description : "",
+            }))
+            : [];
+        const options = field.type === "boolean" && configuredOptions.length === 0
+            ? [
+                { label: "Yes", description: "Answer true." },
+                { label: "No", description: "Answer false." },
+            ]
+            : configuredOptions;
+        return [{
+                id: field.key,
+                header: typeof field.title === "string"
+                    ? field.title
+                    : typeof form.title === "string"
+                        ? form.title
+                        : "OpenCode question",
+                question: typeof field.description === "string"
+                    ? field.description
+                    : typeof field.title === "string"
+                        ? field.title
+                        : field.key,
+                options,
+                multiple: field.type === "multiselect",
+                custom: field.custom === true || options.length === 0,
+            }];
+    });
+}
+function normalizeFormAnswer(field, values) {
+    if (field.type === "multiselect")
+        return values;
+    const value = values[0] ?? "";
+    if (field.type === "boolean") {
+        return /^(1|true|yes|y)$/i.test(String(value));
+    }
+    if (field.type === "number" || field.type === "integer") {
+        const number = Number(value);
+        return Number.isFinite(number) ? number : value;
+    }
+    return value;
+}
+/** Convert OpenCode 2 events to the stable event vocabulary consumed by the adapter. */
+export function normalizeOpenCodeV2Event(value) {
+    if (!isRecord(value) || typeof value.type !== "string")
+        return [];
+    const data = isRecord(value.data) ? value.data : {};
+    const eventLocation = isRecord(value.location) ? value.location : {};
+    const directory = typeof eventLocation.directory === "string"
+        ? eventLocation.directory
+        : undefined;
+    switch (value.type) {
+        case "session.created":
+            return [{ type: "session.created", directory, properties: { info: sessionFromCreatedEvent(data) } }];
+        case "session.deleted":
+            return [{ type: "session.deleted", directory, properties: { sessionID: data.sessionID } }];
+        case "session.status":
+            return [{ type: "session.status", directory, properties: data }];
+        case "session.execution.started":
+            return [{ type: "session.status", directory, properties: { sessionID: data.sessionID, status: { type: "busy" } } }];
+        case "session.execution.succeeded":
+        case "session.execution.interrupted":
+            return [{ type: "session.idle", directory, properties: { sessionID: data.sessionID } }];
+        case "session.execution.failed":
+            return [
+                { type: "session.error", directory, properties: { sessionID: data.sessionID, error: data.error } },
+                { type: "session.idle", directory, properties: { sessionID: data.sessionID } },
+            ];
+        case "session.text.started":
+            return [{
+                    type: "message.part.updated",
+                    directory,
+                    properties: { part: textPart(data, "") },
+                }];
+        case "session.text.delta":
+            return [{
+                    type: "message.part.delta",
+                    directory,
+                    properties: {
+                        sessionID: data.sessionID,
+                        messageID: data.assistantMessageID,
+                        partID: textPart(data).id,
+                        field: "text",
+                        delta: data.delta,
+                    },
+                }];
+        case "session.text.ended":
+            return [{
+                    type: "message.part.updated",
+                    directory,
+                    properties: { part: textPart(data, typeof data.text === "string" ? data.text : "") },
+                }];
+        case "session.inbox.enqueued": {
+            const item = isRecord(data.item) ? data.item : {};
+            const payload = isRecord(item.payload) ? item.payload : {};
+            if (item.type !== "user" || typeof payload.text !== "string")
+                return [];
+            const messageID = typeof data.inboxID === "string" ? data.inboxID : String(value.id ?? "user");
+            return [
+                {
+                    type: "message.updated",
+                    directory,
+                    properties: {
+                        sessionID: data.sessionID,
+                        info: { id: messageID, sessionID: data.sessionID, role: "user" },
+                    },
+                },
+                {
+                    type: "message.part.updated",
+                    directory,
+                    properties: {
+                        sessionID: data.sessionID,
+                        part: {
+                            id: `${messageID}:text:0`,
+                            sessionID: data.sessionID,
+                            messageID,
+                            type: "text",
+                            text: payload.text,
+                        },
+                    },
+                },
+            ];
+        }
+        case "permission.asked":
+            return [{
+                    type: "permission.asked",
+                    directory,
+                    properties: {
+                        ...data,
+                        requestID: data.id,
+                        permission: data.action,
+                        patterns: data.resources,
+                    },
+                }];
+        case "permission.replied":
+            return [{ type: "permission.replied", directory, properties: data }];
+        case "form.created": {
+            const form = isRecord(data.form) ? data.form : {};
+            return [{
+                    type: "question.asked",
+                    directory,
+                    properties: {
+                        sessionID: form.sessionID,
+                        id: form.id,
+                        requestID: form.id,
+                        questions: normalizeFormQuestions(form),
+                    },
+                }];
+        }
+        case "form.replied": {
+            const form = isRecord(data.form) ? data.form : data;
+            return [{
+                    type: "question.replied",
+                    directory,
+                    properties: { sessionID: form.sessionID, requestID: form.id ?? data.formID },
+                }];
+        }
+        case "form.cancelled": {
+            const form = isRecord(data.form) ? data.form : data;
+            return [{
+                    type: "question.rejected",
+                    directory,
+                    properties: { sessionID: form.sessionID, requestID: form.id ?? data.formID },
+                }];
+        }
+        case "server.connected":
+        case "session.idle":
+        case "tui.prompt.append":
+        case "tui.command.execute":
+        case "tui.session.select":
+        case "tui.toast.show":
+            return [{ type: value.type, directory, properties: data }];
+        default:
+            return [];
+    }
+}
+function mapProviders(providersValue, modelsValue) {
+    const providers = isRecord(providersValue) && Array.isArray(providersValue.data)
+        ? providersValue.data.filter(isRecord)
+        : [];
+    const models = isRecord(modelsValue) && Array.isArray(modelsValue.data)
+        ? modelsValue.data.filter(isRecord)
+        : [];
+    const providerById = new Map();
+    for (const provider of providers) {
+        if (typeof provider.id === "string")
+            providerById.set(provider.id, provider);
+    }
+    for (const model of models) {
+        if (typeof model.providerID !== "string" || providerById.has(model.providerID))
+            continue;
+        providerById.set(model.providerID, {
+            id: model.providerID,
+            name: model.providerID,
+            activation: "enabled",
+        });
+    }
+    const all = Array.from(providerById.values()).map((provider) => {
+        const providerID = typeof provider.id === "string" ? provider.id : "";
+        const providerModels = Object.fromEntries(models
+            .filter((model) => model.providerID === providerID && typeof model.id === "string")
+            .map((model) => {
+            const variants = Array.isArray(model.variants)
+                ? Object.fromEntries(model.variants.filter(isRecord).flatMap((variant) => typeof variant.id === "string" ? [[variant.id, variant]] : []))
+                : isRecord(model.variants)
+                    ? model.variants
+                    : {};
+            return [model.id, {
+                    ...model,
+                    name: typeof model.name === "string" ? model.name : model.id,
+                    variants,
+                }];
+        }));
+        return { ...provider, models: providerModels };
+    });
+    return {
+        all,
+        connected: all
+            .filter((provider) => provider.activation !== "disabled" && typeof provider.id === "string")
+            .map((provider) => provider.id),
+    };
+}
+export async function createOpenCodeV2CompatClient(options) {
+    const { OpenCode } = await import("@opencode/client");
+    const client = OpenCode.make({ baseUrl: options.baseUrl, headers: options.headers });
+    const formFields = new Map();
+    const formSessions = new Map();
+    const permissionSessions = new Map();
+    const sessionStatuses = new Map();
+    const waitForPopulatedList = async (load) => {
+        let response;
+        for (let attempt = 0; attempt < 20; attempt += 1) {
+            response = await load();
+            if (isRecord(response) && Array.isArray(response.data) && response.data.length > 0) {
+                return response;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+        return response;
+    };
+    const listAvailableModels = (requestOptions) => waitForPopulatedList(() => client.model.list({ location: directoryLocation }, requestOptions));
+    async function* subscribe(input) {
+        for await (const event of client.event.subscribe(input)) {
+            if (isRecord(event) && event.type === "form.created" && isRecord(event.data) && isRecord(event.data.form)) {
+                const form = event.data.form;
+                if (typeof form.id === "string" && Array.isArray(form.fields)) {
+                    formFields.set(form.id, form.fields.filter(isRecord).filter((field) => typeof field.key === "string"));
+                    if (typeof form.sessionID === "string") {
+                        formSessions.set(form.id, form.sessionID);
+                    }
+                }
+            }
+            if (isRecord(event) && event.type === "permission.asked" && isRecord(event.data)) {
+                if (typeof event.data.id === "string" && typeof event.data.sessionID === "string") {
+                    permissionSessions.set(event.data.id, event.data.sessionID);
+                }
+            }
+            if (isRecord(event) && isRecord(event.data) && typeof event.data.sessionID === "string") {
+                if (event.type === "session.execution.started") {
+                    sessionStatuses.set(event.data.sessionID, "busy");
+                }
+                else if (event.type === "session.execution.succeeded" ||
+                    event.type === "session.execution.failed" ||
+                    event.type === "session.execution.interrupted" ||
+                    event.type === "session.idle") {
+                    sessionStatuses.set(event.data.sessionID, "idle");
+                }
+            }
+            for (const normalized of normalizeOpenCodeV2Event(event)) {
+                yield normalized;
+            }
+        }
+    }
+    const directoryLocation = location(options.directory);
+    return {
+        server: client.server,
+        app: {
+            agents: (_input, requestOptions) => result(async () => {
+                const response = await waitForPopulatedList(() => client.agent.list({ location: directoryLocation }, requestOptions));
+                return isRecord(response) && Array.isArray(response.data)
+                    ? response.data.filter(isRecord).map((agent) => ({
+                        ...agent,
+                        name: typeof agent.id === "string" ? agent.id : agent.name,
+                    }))
+                    : [];
+            }),
+        },
+        provider: {
+            list: (_input, requestOptions) => result(async () => mapProviders(await client.provider.list({ location: directoryLocation }, requestOptions), await listAvailableModels(requestOptions))),
+        },
+        session: {
+            create: (_input, requestOptions) => result(async () => normalizeOpenCodeV2Session(await client.session.create({ location: directoryLocation }, requestOptions))),
+            list: (_input, requestOptions) => result(async () => {
+                const response = await client.session.list({ directory: options.directory, order: "desc" }, requestOptions);
+                return isRecord(response) && Array.isArray(response.data)
+                    ? response.data.map(normalizeOpenCodeV2Session)
+                    : [];
+            }),
+            get: (input, requestOptions) => result(async () => normalizeOpenCodeV2Session(await client.session.get({ sessionID: input.sessionID }, requestOptions))),
+            status: (_input, requestOptions) => result(async () => {
+                const response = await client.session.list({ directory: options.directory, order: "desc" }, requestOptions);
+                const sessions = isRecord(response) && Array.isArray(response.data) ? response.data.filter(isRecord) : [];
+                return Object.fromEntries(sessions.flatMap((session) => {
+                    if (typeof session.id !== "string")
+                        return [];
+                    return [[session.id, { type: sessionStatuses.get(session.id) ?? "idle" }]];
+                }));
+            }),
+            promptAsync: (input, requestOptions) => result(async () => {
+                const parts = Array.isArray(input.parts) ? input.parts.filter(isRecord) : [];
+                const text = parts.flatMap((part) => part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("\n");
+                await client.session.prompt({ sessionID: input.sessionID, text }, requestOptions);
+                return {};
+            }),
+            abort: (input, requestOptions) => result(async () => await client.session.interrupt({ sessionID: input.sessionID }, requestOptions)),
+        },
+        v2: {
+            session: {
+                switchAgent: (input, requestOptions) => result(async () => await client.session.switchAgent(input, requestOptions)),
+                switchModel: (input, requestOptions) => result(async () => await client.session.switchModel(input, requestOptions)),
+            },
+        },
+        permission: {
+            reply: (input, requestOptions) => result(async () => await client.permission.reply({
+                sessionID: input.sessionID ?? permissionSessions.get(String(input.requestID)),
+                requestID: input.requestID,
+                decision: input.reply === "reject" ? "reject" : input.reply,
+            }, requestOptions).finally(() => permissionSessions.delete(String(input.requestID)))),
+        },
+        question: {
+            reply: (input, requestOptions) => result(async () => {
+                const answers = Array.isArray(input.answers) ? input.answers : [];
+                const fields = formFields.get(String(input.requestID)) ?? [];
+                const answer = Object.fromEntries(fields.flatMap((field, index) => {
+                    if (typeof field.key !== "string")
+                        return [];
+                    const values = Array.isArray(answers[index]) ? answers[index] : [];
+                    return [[field.key, normalizeFormAnswer(field, values)]];
+                }));
+                await client.session.form.reply({
+                    sessionID: input.sessionID ?? formSessions.get(String(input.requestID)),
+                    formID: input.requestID,
+                    answer,
+                }, requestOptions);
+                formFields.delete(String(input.requestID));
+                formSessions.delete(String(input.requestID));
+                return {};
+            }),
+            reject: (input, requestOptions) => result(async () => {
+                await client.session.form.cancel({
+                    sessionID: input.sessionID ?? formSessions.get(String(input.requestID)),
+                    formID: input.requestID,
+                }, requestOptions);
+                formFields.delete(String(input.requestID));
+                formSessions.delete(String(input.requestID));
+                return {};
+            }),
+        },
+        event: {
+            subscribe: async (_input, requestOptions) => ({
+                stream: subscribe(requestOptions),
+            }),
+        },
+        tui: {
+            selectSession: async () => ok({}),
+        },
+    };
+}

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

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
+import net from "node:net";
+const ROUTE_POLL_INTERVAL_MS = 100;
+const MAX_BUFFER_SIZE = 1024 * 1024;
+export default {
+    id: "cli-wechat-bridge.session-route-v2",
+    setup(context) {
+        const port = Number(context.options.port);
+        const token = typeof context.options.token === "string" ? context.options.token : "";
+        if (!Number.isInteger(port) || port <= 0 || !token) {
+            return () => undefined;
+        }
+        const socket = net.connect({ host: "127.0.0.1", port });
+        let connected = false;
+        let inputBuffer = "";
+        let lastSessionId;
+        let queuedFrame = null;
+        const writeFrame = (frame) => {
+            if (socket.destroyed)
+                return;
+            if (!connected) {
+                queuedFrame = frame;
+                return;
+            }
+            socket.write(`${JSON.stringify(frame)}\n`);
+        };
+        const publishRoute = () => {
+            const route = context.ui.router.current();
+            const sessionId = route.type === "session" && typeof route.sessionID === "string"
+                ? route.sessionID
+                : null;
+            if (sessionId === lastSessionId)
+                return;
+            lastSessionId = sessionId;
+            writeFrame({
+                type: "route_state",
+                sessionId,
+                observedAt: new Date().toISOString(),
+            });
+        };
+        socket.setEncoding("utf8");
+        socket.on("connect", () => {
+            socket.setNoDelay(true);
+            socket.write(`${JSON.stringify({ type: "hello", token })}\n`);
+            connected = true;
+            publishRoute();
+            if (queuedFrame) {
+                socket.write(`${JSON.stringify(queuedFrame)}\n`);
+                queuedFrame = null;
+            }
+        });
+        socket.on("data", (chunk) => {
+            inputBuffer += chunk;
+            if (inputBuffer.length > MAX_BUFFER_SIZE) {
+                socket.destroy();
+                return;
+            }
+            for (;;) {
+                const newline = inputBuffer.indexOf("\n");
+                if (newline < 0)
+                    break;
+                const line = inputBuffer.slice(0, newline).trim();
+                inputBuffer = inputBuffer.slice(newline + 1);
+                if (!line)
+                    continue;
+                try {
+                    const frame = JSON.parse(line);
+                    if (frame.type === "select_session" && typeof frame.sessionId === "string") {
+                        context.ui.router.navigate({ type: "session", sessionID: frame.sessionId });
+                        publishRoute();
+                    }
+                }
+                catch {
+                    // Ignore malformed bridge frames and keep the visible TUI alive.
+                }
+            }
+        });
+        socket.on("error", () => {
+            // Keep the native TUI usable if the bridge-side observer disappears.
+        });
+        const timer = setInterval(publishRoute, ROUTE_POLL_INTERVAL_MS);
+        timer.unref?.();
+        return () => {
+            clearInterval(timer);
+            socket.destroy();
+        };
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unlinearity/cli-wechat-bridge",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "CLI bridge for Codex, Claude Code, OpenCode, and Pi over WeChat and WeCom",
   "type": "module",
   "files": [
@@ -53,10 +53,12 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
     "@opencode-ai/sdk": "^1.18.0",
+    "@opencode/client": "^2.0.18",
     "@wecom/aibot-node-sdk": "1.0.7",
     "@xterm/headless": "^6.0.0",
     "node-pty": "^1.1.0",
-    "qrcode-terminal": "^0.12.0"
+    "qrcode-terminal": "^0.12.0",
+    "ws": "^8.22.0"
   },
   "overrides": {
     "@hono/node-server": "2.1.1",