cli-wechat-bridge 1.1.7 → 1.2.0

package/dist/bridge/bridge-adapters.core.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 net from "node:net";
 import path from "node:path";
 import { spawn as spawnPty } from "node-pty";
@@ -15,7 +21,7 @@ const { CODEX_APP_SERVER_HOST, INTERRUPT_SETTLE_DELAY_MS, buildCliEnvironment, b
  * the script path contains spaces: node-pty quotes the already-quoted path,
  * making cmd.exe treat the literal quotes as part of the filename.
  */
-function unwrapCmdExeForPty(rawTarget) {
+export function unwrapCmdExeForPty(rawTarget) {
     if (process.platform !== "win32") {
         return rawTarget;
     }
@@ -166,6 +172,15 @@ export class LocalCompanionProxyAdapter {
             command: "create_session",
         });
     }
+    async listModels() {
+        return await this.sendRequest({ command: "list_models" });
+    }
+    async selectModel(modelId) {
+        return await this.sendRequest({ command: "select_model", modelId });
+    }
+    async setPlanMode(enabled) {
+        return await this.sendRequest({ command: "set_plan_mode", enabled });
+    }
     async interrupt() {
         const result = await this.sendRequest({
             command: "interrupt",
@@ -612,6 +627,15 @@ export class AbstractPtyAdapter {
     setEventSink(sink) {
         this.eventSink = sink;
     }
+    async listModels() {
+        throw new Error(`/${this.options.kind} model selection is not available.`);
+    }
+    async selectModel(_modelId) {
+        throw new Error(`/${this.options.kind} model selection is not available.`);
+    }
+    async setPlanMode(_enabled) {
+        throw new Error(`/${this.options.kind} plan mode is not available.`);
+    }
     async start() {
         if (this.pty) {
             return;

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";
@@ -85,6 +91,139 @@ export class OpenCodeServerAdapter {
     pendingLocalSessionCreateFollowUntilMs = 0;
     pendingPermission = null;
     pendingQuestion = null;
+    previousAgentBySession = new Map();
+    async listModels() {
+        this.assertRemoteControlReady();
+        const session = await this.ensureControlSession();
+        const models = await this.listControlModels();
+        return models.map((model) => ({
+            id: model.id,
+            displayName: model.displayName,
+            isCurrent: session.model?.providerID === model.providerID &&
+                session.model.id === model.modelID,
+        }));
+    }
+    async selectModel(modelId) {
+        this.assertRemoteControlReady();
+        const session = await this.ensureControlSession();
+        const models = await this.listControlModels();
+        const target = models.find((model) => model.id === modelId);
+        if (!target) {
+            throw new Error("This OpenCode model is no longer available. Send /model again.");
+        }
+        const currentVariant = session.model?.variant;
+        const variant = currentVariant && currentVariant !== "default" && target.variants.includes(currentVariant)
+            ? currentVariant
+            : "default";
+        const result = await this.client.v2.session.switchModel({
+            sessionID: session.id,
+            model: {
+                providerID: target.providerID,
+                id: target.modelID,
+                variant,
+            },
+        });
+        this.unwrapOrThrow(result);
+        const updated = await this.getSessionForCurrentDirectory(session.id);
+        if (!updated ||
+            updated.model?.providerID !== target.providerID ||
+            updated.model.id !== target.modelID ||
+            (updated.model.variant ?? "default") !== variant) {
+            throw new Error("OpenCode did not confirm the selected model.");
+        }
+        return { id: target.id, displayName: target.displayName, isCurrent: true };
+    }
+    async setPlanMode(enabled) {
+        this.assertRemoteControlReady();
+        const session = await this.ensureControlSession();
+        const agents = await this.listPrimaryAgents();
+        const planAgent = agents.find((agent) => agent.name === "plan");
+        if (!planAgent) {
+            throw new Error("OpenCode primary agent 'plan' is not available.");
+        }
+        const currentAgent = session.agent ?? agents[0]?.name;
+        if (!currentAgent) {
+            throw new Error("OpenCode did not return any primary agents.");
+        }
+        if (enabled && currentAgent === "plan") {
+            return true;
+        }
+        if (!enabled && currentAgent !== "plan") {
+            this.previousAgentBySession.delete(session.id);
+            return false;
+        }
+        const previousAgent = this.previousAgentBySession.get(session.id);
+        const target = enabled
+            ? "plan"
+            : agents.some((agent) => agent.name === previousAgent)
+                ? previousAgent
+                : agents.find((agent) => agent.name === "build")?.name ??
+                    agents.find((agent) => agent.name !== "plan")?.name;
+        if (!target) {
+            throw new Error("OpenCode did not return an agent that can replace plan mode.");
+        }
+        const result = await this.client.v2.session.switchAgent({
+            sessionID: session.id,
+            agent: target,
+        });
+        this.unwrapOrThrow(result);
+        const updated = await this.getSessionForCurrentDirectory(session.id);
+        if (!updated || updated.agent !== target) {
+            throw new Error("OpenCode did not confirm the selected agent.");
+        }
+        if (enabled) {
+            this.previousAgentBySession.set(session.id, currentAgent);
+        }
+        else {
+            this.previousAgentBySession.delete(session.id);
+        }
+        return enabled;
+    }
+    assertRemoteControlReady() {
+        if (!this.client) {
+            throw new Error("OpenCode is not running.");
+        }
+        if (this.state.status === "busy") {
+            throw new Error("OpenCode is still working. Wait for the current reply or use /stop.");
+        }
+        if (this.pendingPermission) {
+            throw new Error("An OpenCode approval request is pending. Reply with /confirm or /deny.");
+        }
+        if (this.pendingQuestion) {
+            throw new Error("OpenCode is waiting for user input. Reply with /answer or use /stop.");
+        }
+    }
+    async ensureControlSession() {
+        const session = await this.ensureSession();
+        if (session.id !== this.activeSessionId) {
+            this.switchSharedSession(session, {
+                source: "wechat",
+                reason: "wechat_resume",
+                syncVisible: true,
+                forceVisibleSync: true,
+            });
+        }
+        return session;
+    }
+    async listPrimaryAgents() {
+        if (!this.client)
+            throw new Error("OpenCode is not running.");
+        const agents = this.unwrapOrThrow(await this.client.app.agents({
+            directory: this.options.cwd,
+            workspace: this.activeWorkspaceId ?? undefined,
+        }, { signal: AbortSignal.timeout(10_000) }));
+        return agents.filter((agent) => agent.mode !== "subagent" && !agent.hidden);
+    }
+    async listControlModels() {
+        if (!this.client)
+            throw new Error("OpenCode is not running.");
+        const providers = this.unwrapOrThrow(await this.client.provider.list({ directory: this.options.cwd, workspace: this.activeWorkspaceId ?? undefined }, { signal: AbortSignal.timeout(10_000) }));
+        return providers.all.filter((provider) => providers.connected.includes(provider.id)).flatMap((provider) => Object.entries(provider.models).filter(([id, model]) => model.status !== "deprecated" && !(provider.id === "opencode" && id.includes("-nano"))).map(([id, model]) => ({
+            id: `${provider.id}/${id}`, displayName: `${model.name || id} (${provider.name})`,
+            providerID: provider.id, modelID: id,
+            variants: Object.keys(model.variants ?? {}),
+        })));
+    }
     constructor(options) {
         this.options = options;
         this.state = {
@@ -170,10 +309,21 @@ export class OpenCodeServerAdapter {
         this.recordPendingWechatPromptMirrorSuppression(session.id, normalized);
         this.beginTrackedTurn(normalized, "wechat");
         try {
+            const selection = await this.getSessionForCurrentDirectory(session.id) ?? session;
             const result = await this.client.session.promptAsync({
                 sessionID: session.id,
                 directory: this.options.cwd,
                 workspace: session.workspaceID ?? this.activeWorkspaceId ?? undefined,
+                ...(selection.agent ? { agent: selection.agent } : {}),
+                ...(selection.model
+                    ? {
+                        model: {
+                            providerID: selection.model.providerID,
+                            modelID: selection.model.id,
+                        },
+                        variant: selection.model.variant ?? "default",
+                    }
+                    : {}),
                 parts: [{ type: "text", text: normalized }],
             });
             if (result.error !== undefined) {
@@ -411,6 +561,7 @@ export class OpenCodeServerAdapter {
         this.pendingLocalSessionCreateFollowUntilMs = 0;
         this.clearObservedMessageTracking();
         this.recentSdkEventObservations.clear();
+        this.previousAgentBySession.clear();
         this.outputBatcher.clear();
         this.clearStreamedPartState();
         this.clearPendingPermissionState();
@@ -1535,7 +1686,11 @@ export class OpenCodeServerAdapter {
             return;
         }
         const sessionId = this.extractSessionId(properties);
-        if (!sessionId || sessionId !== this.activeSessionId) {
+        if (!sessionId) {
+            return;
+        }
+        this.previousAgentBySession.delete(sessionId);
+        if (sessionId !== this.activeSessionId) {
             return;
         }
         this.clearTrackedTurnForLocalSessionSwitch();

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";
@@ -356,6 +362,41 @@ export class PiTuiAdapter {
             this.pendingSessionSwitch = null;
         }
     }
+    async listModels() {
+        if (this.state.status === "busy") {
+            throw new Error("Pi is still working. Wait for the current turn before listing models.");
+        }
+        const response = await this.sendCommand("list_models");
+        if (!isRecord(response.data) || !Array.isArray(response.data.models)) {
+            throw new Error("Pi TUI returned an invalid model list.");
+        }
+        return response.data.models
+            .filter((model) => isRecord(model))
+            .filter((model) => typeof model.id === "string" && typeof model.displayName === "string")
+            .map((model) => ({
+            id: model.id,
+            displayName: model.displayName,
+            isCurrent: model.isCurrent === true,
+        }));
+    }
+    async selectModel(modelId) {
+        if (this.state.status === "busy") {
+            throw new Error("Pi is still working. Wait for the current turn before switching models.");
+        }
+        const response = await this.sendCommand("select_model", { modelId });
+        if (!isRecord(response.data) || !isRecord(response.data.model)) {
+            throw new Error("Pi TUI returned an invalid selected model.");
+        }
+        const model = response.data.model;
+        if (typeof model.id !== "string" || typeof model.displayName !== "string") {
+            throw new Error("Pi TUI returned an invalid selected model.");
+        }
+        return {
+            id: model.id,
+            displayName: model.displayName,
+            isCurrent: true,
+        };
+    }
     async interrupt() {
         if (!this.socket || this.state.status !== "busy") {
             return false;
@@ -569,6 +610,10 @@ export class PiTuiAdapter {
             else if (this.currentAssistantText) {
                 this.emit({ type: "final_reply", text: this.currentAssistantText, timestamp: nowIso() });
             }
+            // Mirror the other adapters: a settled turn always reports completion so
+            // bridge/daemon ownership state is released even when the turn produced
+            // no visible reply.
+            this.emit({ type: "task_complete", timestamp: nowIso() });
             this.state.lastOutputAt = nowIso();
             this.clearActiveTurn();
             this.setStatus("idle");

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

@@ -0,0 +1,133 @@
+import { NativeTerminalControl, parseClaudeModelPicker, readClaudePermissionMode } from "./native-terminal-control.js";
+export class ClaudeNativeControls {
+    previousMode = null;
+    terminal;
+    session;
+    constructor(terminal, session) {
+        this.terminal = terminal;
+        this.session = session;
+    }
+    assertPrompt() {
+        if (readClaudePermissionMode(this.terminal.text) === null) {
+            throw new Error("Claude must be at an empty native prompt before changing models or plan mode.");
+        }
+    }
+    async listModels() {
+        return this.terminal.run(async () => {
+            this.assertPrompt();
+            await this.terminal.openMenu("/model", "Select model");
+            const options = new Map();
+            const visited = new Set();
+            const initial = parseClaudeModelPicker(this.terminal.text).find((option) => option.focused)?.index;
+            while (true) {
+                const rows = parseClaudeModelPicker(this.terminal.text);
+                for (const row of rows) {
+                    options.set(row.index, {
+                        id: JSON.stringify({ index: row.index, label: row.label }),
+                        displayName: row.label,
+                        isCurrent: row.current || row.index === initial,
+                    });
+                }
+                const focused = rows.find((row) => row.focused);
+                if (!focused)
+                    throw new Error("Could not identify the focused Claude model. Close the menu and try again.");
+                if (visited.has(focused.index))
+                    break;
+                visited.add(focused.index);
+                await this.terminal.key("\u001b[B");
+            }
+            // A clamped selector can start in the middle; walk upwards to capture earlier hidden rows too.
+            const visitedUp = new Set();
+            while (true) {
+                const rows = parseClaudeModelPicker(this.terminal.text);
+                for (const row of rows) {
+                    options.set(row.index, { id: JSON.stringify({ index: row.index, label: row.label }), displayName: row.label, isCurrent: row.current || row.index === initial });
+                }
+                const focused = rows.find((row) => row.focused);
+                if (!focused)
+                    throw new Error("Could not identify the focused Claude model.");
+                if (visitedUp.has(focused.index))
+                    break;
+                visitedUp.add(focused.index);
+                if (focused.index === 1)
+                    break;
+                await this.terminal.key("\u001b[A");
+            }
+            await this.terminal.closeMenu();
+            return [...options.entries()].filter(([index]) => visited.has(index) || visitedUp.has(index)).sort(([a], [b]) => a - b).map(([, option]) => option);
+        });
+    }
+    async selectModel(id) {
+        const target = JSON.parse(id);
+        if (!Number.isSafeInteger(target.index) || target.index < 1 || typeof target.label !== "string")
+            throw new Error("Invalid Claude model selection. Send /model again.");
+        return this.terminal.run(async () => {
+            this.assertPrompt();
+            await this.terminal.openMenu("/model", "Select model");
+            const visited = new Set();
+            while (true) {
+                const focused = parseClaudeModelPicker(this.terminal.text).find((row) => row.focused);
+                if (!focused)
+                    throw new Error("Could not identify the focused Claude model.");
+                if (focused.index === target.index) {
+                    if (focused.label !== target.label)
+                        throw new Error("The Claude model list changed. Send /model again.");
+                    break;
+                }
+                if (visited.has(focused.index))
+                    throw new Error("The Claude model is no longer selectable. Send /model again.");
+                visited.add(focused.index);
+                await this.terminal.key(focused.index < target.index ? "\u001b[B" : "\u001b[A");
+            }
+            if (!/s to use this session only/i.test(this.terminal.text)) {
+                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.openMenu("/model", "Select model");
+            const applied = parseClaudeModelPicker(this.terminal.text).find((row) => row.focused);
+            if (!applied || applied.label !== target.label || applied.index !== target.index)
+                throw new Error("Claude did not confirm the selected model.");
+            await this.terminal.closeMenu();
+            return { id, displayName: target.label, isCurrent: true };
+        });
+    }
+    async setPlanMode(enabled) {
+        return this.terminal.run(async () => {
+            this.assertPrompt();
+            const current = readClaudePermissionMode(this.terminal.text);
+            const session = this.session();
+            if (this.previousMode?.session !== session)
+                this.previousMode = null;
+            if (enabled) {
+                if (current === "plan")
+                    return true;
+                if (!["default", "acceptEdits", "bypassPermissions", "auto"].includes(current)) {
+                    throw new Error(`Claude cannot restore permission mode ${current} through the native mode switch.`);
+                }
+                await this.terminal.command("/plan");
+                await this.terminal.waitFor(() => readClaudePermissionMode(this.terminal.text) === "plan");
+                this.previousMode = { session, mode: current };
+                return true;
+            }
+            if (current !== "plan") {
+                this.previousMode = null;
+                return false;
+            }
+            const target = this.previousMode?.mode ?? "default";
+            const visited = new Set();
+            while (true) {
+                const mode = readClaudePermissionMode(this.terminal.text);
+                if (mode === target)
+                    break;
+                if (!mode || visited.has(mode))
+                    throw new Error(`Claude could not restore ${target}; check the native permission mode.`);
+                visited.add(mode);
+                await this.terminal.key("\u001b[Z");
+                await this.terminal.waitFor(() => readClaudePermissionMode(this.terminal.text) !== mode);
+            }
+            this.previousMode = null;
+            return false;
+        });
+    }
+}