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)