cli-wechat-bridge 1.1.8 → 1.2.1

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

@@ -1,3 +1,9 @@
+// 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 { spawn as spawnChildProcess } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import fs from "node:fs";
@@ -6,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 ?? "");
@@ -18,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);
@@ -77,6 +88,8 @@ export class OpenCodeServerAdapter {
     tuiRoutePort = 0;
     tuiRouteConfigDir = null;
     tuiRouteConfigPath = null;
+    tuiRoutePluginPath = null;
+    openCodeMajor = 1;
     visibleTuiSessionId = null;
     tuiRouteStateReceived = false;
     expectedVisibleTuiSessionId = null;
@@ -244,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);
@@ -626,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: [
                 [
@@ -644,7 +673,6 @@ export class OpenCodeServerAdapter {
                 ],
             ],
         }, null, 2)}\n`, "utf8");
-        this.tuiRouteConfigDir = configDir;
         this.tuiRouteConfigPath = configPath;
     }
     acceptTuiRouteSocket(socket) {
@@ -759,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;
@@ -775,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");
@@ -880,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);
@@ -891,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.");
             }
@@ -905,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,
@@ -922,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}`,
@@ -931,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() {
@@ -946,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;
@@ -1093,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) {
@@ -2739,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/bridge-adapters.pi.js

@@ -1,3 +1,9 @@
+// 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 crypto from "node:crypto";
 import fs from "node:fs";
 import net from "node:net";

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

@@ -1,3 +1,9 @@
+// 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 fs from "node:fs";
 import os from "node:os";
 import path from "node:path";

package/dist/bridge/bridge-controller.js

@@ -1,3 +1,9 @@
+// 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 { clearLocalCompanionEndpoint, readLocalCompanionEndpoint, writeLocalCompanionEndpoint, } from "../companion/local-companion-link.js";
 import { hasLocalClientEndpointProvider } from "../runtime/runtime-types.js";
 export class BridgeController {

package/dist/bridge/bridge-final-reply.js

@@ -1,2 +1,8 @@
+// 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.
 /** @deprecated Import from ../channels/wechat/bridge-final-reply.ts instead. */
 export * from "../channels/wechat/bridge-final-reply.js";

package/dist/bridge/bridge-process-reaper.js

@@ -1,3 +1,9 @@
+// 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 { spawnSync } from "node:child_process";
 import path from "node:path";
 const PEER_BRIDGE_EXIT_TIMEOUT_MS = 4_000;

package/dist/bridge/bridge-state.js

@@ -1,3 +1,9 @@
+// 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 fs from "node:fs";
 import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, appendBoundedLog, ensureWorkspaceChannelDir, ensureChannelDataDir, } from "../wechat/channel-config.js";
 import { buildInstanceId } from "../core/text-utils.js";

package/dist/bridge/bridge-utils.js

@@ -1,3 +1,9 @@
+// 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 fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -1113,37 +1119,6 @@ export function isStrictApprovalModeEnabled(env = process.env) {
     const value = env.CLI_BRIDGE_STRICT_APPROVAL?.trim().toLowerCase();
     return value === "1" || value === "true" || value === "yes" || value === "on";
 }
-// Outbound WeChat text size cap shared by the streaming OutputBatcher and the
-// final-reply forwarder. Long replies sent as a single sendmessage call can be
-// rejected by the server, which previously made long final replies vanish.
-export const WECHAT_TEXT_CHUNK_MAX_CHARS = 1_200;
-export function splitWechatTextIntoChunks(text, maxChars = WECHAT_TEXT_CHUNK_MAX_CHARS) {
-    const normalized = text.trim();
-    if (!normalized) {
-        return [];
-    }
-    if (normalized.length <= maxChars) {
-        return [normalized];
-    }
-    const chunks = [];
-    let remaining = normalized;
-    while (remaining.length > maxChars) {
-        // Prefer breaking at a newline reasonably close to the cap so paragraphs
-        // stay intact; fall back to a hard split.
-        const window = remaining.slice(0, maxChars + 1);
-        const newlineIndex = window.lastIndexOf("\n");
-        const splitIndex = newlineIndex > maxChars / 2 ? newlineIndex : maxChars;
-        const chunk = remaining.slice(0, splitIndex).trim();
-        if (chunk) {
-            chunks.push(chunk);
-        }
-        remaining = remaining.slice(splitIndex).trim();
-    }
-    if (remaining) {
-        chunks.push(remaining);
-    }
-    return chunks;
-}
 export function shouldDropStartupBacklogMessage(createdAtMs, bridgeStartedAtMs, graceMs = MESSAGE_START_GRACE_MS) {
     // A missing or unparsable timestamp must not drop the message: treat it as
     // fresh and let normal processing continue.

package/dist/bridge/claude-hook.js

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+// 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 crypto from "node:crypto";
 import net from "node:net";
 async function readStdin() {

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

@@ -1,3 +1,9 @@
+// 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 xterm from "@xterm/headless";
 const { Terminal } = xterm;
 const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -239,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));