cli-wechat-bridge 1.1.7 → 1.2.0

package/dist/companion/codex-visible-client-link.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 net from "node:net";
 import { readLocalCompanionEndpoint, } from "./local-companion-link.js";
@@ -23,12 +29,37 @@ export function parseCodexVisibleSwitchRequest(value) {
         threadId: value.threadId,
     };
 }
+export function parseCodexVisibleControlRequest(value) {
+    const switchRequest = parseCodexVisibleSwitchRequest(value);
+    if (switchRequest) {
+        return switchRequest;
+    }
+    if (!isRecord(value)) {
+        return null;
+    }
+    if (value.type !== "shutdown" ||
+        typeof value.id !== "string" ||
+        typeof value.token !== "string") {
+        return null;
+    }
+    return {
+        type: "shutdown",
+        id: value.id,
+        token: value.token,
+    };
+}
 export function sendCodexVisibleSwitchResponse(socket, response) {
     if (socket.destroyed || socket.writableEnded) {
         return;
     }
     socket.end(`${JSON.stringify(response)}\n`);
 }
+export function sendCodexVisibleShutdownResponse(socket, response) {
+    if (socket.destroyed || socket.writableEnded) {
+        return;
+    }
+    socket.end(`${JSON.stringify(response)}\n`);
+}
 function resolveCodexControlEndpoint(cwd, instanceId) {
     const endpoint = readLocalCompanionEndpoint(cwd, { adapter: "codex" });
     if (!endpoint || endpoint.kind !== "codex" || endpoint.instanceId !== instanceId) {
@@ -120,3 +151,79 @@ export async function requestCodexVisibleThreadSwitch(params) {
         });
     });
 }
+export async function requestCodexVisibleClientShutdown(params) {
+    const endpoint = resolveCodexControlEndpoint(params.cwd, params.instanceId);
+    const requestId = crypto.randomUUID();
+    const timeoutMs = params.timeoutMs ?? 5_000;
+    await new Promise((resolve, reject) => {
+        const socket = net.connect({
+            host: CODEX_VISIBLE_CONTROL_HOST,
+            port: endpoint.codexControlPort,
+        });
+        let buffer = "";
+        let settled = false;
+        const finish = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            socket.destroy();
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        };
+        socket.setEncoding("utf8");
+        socket.setTimeout(timeoutMs);
+        socket.once("connect", () => {
+            const request = {
+                type: "shutdown",
+                id: requestId,
+                token: endpoint.codexControlToken,
+            };
+            socket.write(`${JSON.stringify(request)}\n`);
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            if (buffer.length > 65_536) {
+                finish(new Error("The visible Codex client returned an oversized shutdown response."));
+                return;
+            }
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex < 0) {
+                return;
+            }
+            const line = buffer.slice(0, newlineIndex).trim();
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                finish(new Error("The visible Codex client returned an invalid shutdown response."));
+                return;
+            }
+            if (!isRecord(parsed) || parsed.type !== "shutdown_result" || parsed.id !== requestId) {
+                finish(new Error("The visible Codex client returned an unexpected shutdown response."));
+                return;
+            }
+            if (parsed.ok !== true) {
+                finish(new Error(typeof parsed.error === "string"
+                    ? parsed.error
+                    : "The visible Codex client could not shut down."));
+                return;
+            }
+            finish();
+        });
+        socket.once("timeout", () => {
+            finish(new Error("Timed out waiting for the visible Codex client to shut down."));
+        });
+        socket.once("error", (error) => finish(error));
+        socket.once("close", () => {
+            if (!settled) {
+                finish(new Error("The visible Codex client closed the shutdown connection."));
+            }
+        });
+    });
+}

package/dist/companion/local-companion-link.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 { ensureWorkspaceChannelDir, getWorkspaceAdapterEndpointFile, getWorkspaceChannelPaths, } from "../wechat/channel-config.js";

package/dist/companion/local-companion-start.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 net from "node:net";
 import path from "node:path";
 import { spawn } from "node:child_process";
@@ -39,8 +45,13 @@ export function formatSwitchFailureMessage(cwd) {
 export function formatRestartUnhealthyMessage(cwd) {
     return `Detected unhealthy companion state for ${cwd}. Restarting bridge...`;
 }
-export function defaultSessionStartMode(adapter) {
-    return adapter === "codex" ? "restore" : "new";
+export function defaultSessionStartMode(_adapter) {
+    // Codex 0.155+ persists app-server threads lazily, so launching the visible
+    // client with a freshly prepared (not yet persisted) thread id crashes its
+    // bootstrap with "no rollout found". Start every adapter fresh by default;
+    // explicit --session-start-mode restore remains available for deliberate
+    // restores of already persisted threads.
+    return "new";
 }
 export function decideLaunchAction(input) {
     if (input.lockShouldAutoReclaim) {

package/dist/companion/local-companion.js

@@ -1,4 +1,10 @@
 #!/usr/bin/env bun
+// 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 { createBridgeAdapter } from "../bridge/bridge-adapters.js";
@@ -231,6 +237,23 @@ export async function runLocalCompanion(options) {
                     publishState();
                     sendResponse(socket, message.id, true);
                     break;
+                case "list_models":
+                    if (!adapter.listModels)
+                        throw new Error("Model listing is not supported by this companion.");
+                    sendResponse(socket, message.id, true, await adapter.listModels());
+                    break;
+                case "select_model":
+                    if (!adapter.selectModel)
+                        throw new Error("Model selection is not supported by this companion.");
+                    sendResponse(socket, message.id, true, await adapter.selectModel(message.payload.modelId));
+                    publishState();
+                    break;
+                case "set_plan_mode":
+                    if (!adapter.setPlanMode)
+                        throw new Error("Plan mode is not supported by this companion.");
+                    sendResponse(socket, message.id, true, await adapter.setPlanMode(message.payload.enabled));
+                    publishState();
+                    break;
                 case "interrupt":
                     sendResponse(socket, message.id, true, await adapter.interrupt());
                     break;

package/dist/companion/opencode-tui-bridge-plugin.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";
 const ROUTE_POLL_INTERVAL_MS = 100;
 const MAX_BUFFER_SIZE = 1024 * 1024;

package/dist/companion/pi-tui-bridge-extension.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 net from "node:net";
 import path from "node:path";
@@ -167,7 +173,7 @@ export default function piTuiBridgeExtension(pi) {
             }
         },
     });
-    const executeCommand = (command) => {
+    const executeCommand = async (command) => {
         try {
             if (command.type === "prompt" && typeof command.text === "string") {
                 if (!latestContext?.isIdle()) {
@@ -180,6 +186,59 @@ export default function piTuiBridgeExtension(pi) {
                 latestContext?.abort();
                 writeFrame({ type: "response", id: command.id, success: true });
             }
+            else if (command.type === "list_models") {
+                if (!latestContext) {
+                    throw new Error("Pi session context is not ready.");
+                }
+                const models = latestContext.scopedModels.length > 0
+                    ? latestContext.scopedModels.map((entry) => entry.model)
+                    : latestContext.modelRegistry.getAvailable();
+                writeFrame({
+                    type: "response",
+                    id: command.id,
+                    success: true,
+                    data: {
+                        models: models.map((model) => ({
+                            id: `${model.provider}/${model.id}`,
+                            displayName: model.name
+                                ? `${model.name} (${model.provider})`
+                                : `${model.id} (${model.provider})`,
+                            isCurrent: latestContext?.model?.provider === model.provider &&
+                                latestContext.model.id === model.id,
+                        })),
+                    },
+                });
+            }
+            else if (command.type === "select_model" && typeof command.modelId === "string") {
+                if (!latestContext?.isIdle()) {
+                    throw new Error("Pi TUI is already processing a turn.");
+                }
+                const models = latestContext.scopedModels.length > 0
+                    ? latestContext.scopedModels.map((entry) => entry.model)
+                    : latestContext.modelRegistry.getAvailable();
+                const model = models.find((candidate) => `${candidate.provider}/${candidate.id}` === command.modelId);
+                if (!model) {
+                    throw new Error(`Pi model is no longer available: ${command.modelId}`);
+                }
+                const selected = await pi.setModel(model);
+                if (!selected) {
+                    throw new Error(`Pi could not switch to model: ${command.modelId}`);
+                }
+                writeFrame({
+                    type: "response",
+                    id: command.id,
+                    success: true,
+                    data: {
+                        model: {
+                            id: `${model.provider}/${model.id}`,
+                            displayName: model.name
+                                ? `${model.name} (${model.provider})`
+                                : `${model.id} (${model.provider})`,
+                            isCurrent: true,
+                        },
+                    },
+                });
+            }
             else if (command.type === "new_session" && typeof command.id === "string") {
                 pi.sendUserMessage(`/${INTERNAL_NEW_COMMAND} ${command.id}`, {
                     expandPromptTemplates: true,
@@ -245,7 +304,7 @@ export default function piTuiBridgeExtension(pi) {
             try {
                 const parsed = JSON.parse(line);
                 if (isRecord(parsed)) {
-                    dispatchCommand(parsed);
+                    void dispatchCommand(parsed);
                 }
             }
             catch {
@@ -260,7 +319,7 @@ export default function piTuiBridgeExtension(pi) {
         latestContext = context;
         writeSessionState(context, typeof event.reason === "string" ? event.reason : "startup");
         for (const command of queuedCommands.splice(0)) {
-            executeCommand(command);
+            void executeCommand(command);
         }
     });
     pi.on("input", (event, context) => {

package/dist/core/bridge-control.js

@@ -26,6 +26,16 @@ export function parseBridgeControlCommand(text) {
             return { type: "deny" };
         case "/answer":
             return argument ? { type: "answer", raw: argument } : null;
+        case "/model":
+            return { type: "model", target: argument || undefined };
+        case "/plan":
+            if (!argument || argument.toLowerCase() === "on")
+                return { type: "plan", enabled: true };
+            if (argument.toLowerCase() === "off")
+                return { type: "plan", enabled: false };
+            return null;
+        case "/all":
+            return argument ? { type: "broadcast", text: argument } : null;
         default:
             return null;
     }

package/dist/core/bridge-defer.js

@@ -0,0 +1,25 @@
+export function shouldDeferCodexInboundMessage(params) {
+    return (params.adapter === "codex" &&
+        !params.hasPendingConfirmation &&
+        !params.hasSystemCommand &&
+        params.activeTurnOrigin === "local" &&
+        (params.status === "busy" || params.status === "awaiting_approval"));
+}
+export function canDrainDeferredCodexInboundQueue(params) {
+    return (params.adapter === "codex" &&
+        params.deferredCount > 0 &&
+        !params.hasPendingConfirmation &&
+        !params.hasPendingUserInput &&
+        !params.hasPendingApproval &&
+        !params.hasActiveTask &&
+        !params.activeTurnId &&
+        params.status !== "busy" &&
+        params.status !== "awaiting_approval" &&
+        params.status !== "awaiting_input");
+}
+export function formatDeferredCodexInboundQueueMessage(queuePosition) {
+    return `Queued for delivery after the current local Codex turn finishes. Queue position: ${queuePosition}.`;
+}
+export function isRetryableDeferredCodexDrainError(errorText) {
+    return /still working|approval request is pending|waiting for local terminal input/i.test(errorText);
+}

package/dist/core/channel-driver.js

@@ -0,0 +1 @@
+export {};

package/dist/core/conversation-routing.js

@@ -0,0 +1,58 @@
+// 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 { AsyncLocalStorage } from "node:async_hooks";
+/**
+ * Keeps the reply target scoped to one inbound async call chain. Different
+ * conversations may run concurrently without overwriting each other's target.
+ */
+export class InboundConversationContext {
+    storage = new AsyncLocalStorage();
+    run(conversation, callback) {
+        return this.storage.run(conversation, callback);
+    }
+    get() {
+        return this.storage.getStore();
+    }
+}
+export function tryBeginTurn(state, task, conversation) {
+    if (state.activeTask) {
+        return null;
+    }
+    const lease = {
+        task,
+        previousConversation: state.activeConversation,
+        previousLastConversation: state.lastConversation,
+    };
+    state.activeTask = task;
+    if (conversation) {
+        state.activeConversation = conversation;
+        state.lastConversation = conversation;
+    }
+    return lease;
+}
+export function rollbackTurn(state, lease, options = {}) {
+    if (state.activeTask !== lease.task) {
+        return false;
+    }
+    state.activeTask = null;
+    state.activeConversation = lease.previousConversation;
+    if (options.restoreLastConversation) {
+        state.lastConversation = lease.previousLastConversation;
+    }
+    return true;
+}
+export function clearTurn(state, expectedTask) {
+    if (expectedTask && state.activeTask !== expectedTask) {
+        return false;
+    }
+    state.activeTask = null;
+    state.activeConversation = undefined;
+    return true;
+}
+export function resolveConversationTarget(params) {
+    return params.active ?? params.last ?? params.fallback;
+}

package/dist/core/direct-run.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 path from "node:path";
 import { fileURLToPath } from "node:url";
 function normalizeComparablePath(filePath) {

package/dist/core/inbound-message-claims.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 path from "node:path";

package/dist/core/outbound-target.js

@@ -0,0 +1,32 @@
+/**
+ * Outbound target priority for standalone bridges:
+ * 1. an explicit override captured at enqueue time;
+ * 2. for the operator on multi-conversation channels, the pre-resolved turn
+ *    target (callers pass `TurnCoordinator.resolveTarget(operatorConversation)`);
+ * 3. otherwise a direct conversation to the sender.
+ */
+export function resolveOutboundConversationTarget(params) {
+    if (params.override) {
+        return params.override;
+    }
+    if (params.multiConversation && params.senderId === params.operatorId) {
+        return params.operatorTarget;
+    }
+    return params.directConversation(params.senderId);
+}
+/**
+ * Outbound target priority for daemon sends. Multi-conversation operators
+ * resolve through the current inbound conversation first, then the active
+ * slot's remembered target, then the daemon fallback conversation.
+ */
+export function resolveDaemonOutboundTarget(params) {
+    if (params.override) {
+        return params.override;
+    }
+    if (params.multiConversation && params.senderId === params.operatorId) {
+        return params.inboundConversation
+            ?? params.activeSlotTarget
+            ?? params.fallbackConversation;
+    }
+    return params.directConversation(params.senderId);
+}

package/dist/core/text-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.
 const ANSI_ESCAPE_RE = 
 // eslint-disable-next-line no-control-regex
 /\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;

package/dist/core/turn-coordinator.js

@@ -0,0 +1,85 @@
+import { clearTurn, resolveConversationTarget, rollbackTurn, tryBeginTurn, } from "./conversation-routing.js";
+/**
+ * Owns the active remote turn for one dispatch surface: a standalone bridge
+ * or one daemon adapter slot. Wraps the turn ownership state machine (busy
+ * rejection, dispatch rollback, conditional completion) so standalone and
+ * daemon share identical gating semantics instead of re-implementing them.
+ */
+export class TurnCoordinator {
+    state;
+    restoreLastConversationOnFailure;
+    constructor(options = {}) {
+        this.state = {
+            activeTask: null,
+            lastConversation: options.initialLastConversation ?? null,
+        };
+        this.restoreLastConversationOnFailure = options.restoreLastConversationOnFailure ?? false;
+    }
+    get activeTask() {
+        return this.state.activeTask;
+    }
+    get hasActiveTask() {
+        return this.state.activeTask !== null;
+    }
+    get activeConversation() {
+        return this.state.activeConversation;
+    }
+    get lastConversation() {
+        return this.state.lastConversation;
+    }
+    beginTurn(task, conversation) {
+        return tryBeginTurn(this.state, task, conversation);
+    }
+    rollback(lease, options = {}) {
+        return rollbackTurn(this.state, lease, options);
+    }
+    complete(expectedTask) {
+        return clearTurn(this.state, expectedTask);
+    }
+    /**
+     * Replaces the active task unconditionally. Used when a command path
+     * (approval confirmation, resume) takes over a continuing turn rather
+     * than dispatching fresh input.
+     */
+    setActiveTask(task) {
+        this.state.activeTask = task;
+    }
+    /** Binds a conversation as both active and remembered target. */
+    bindConversation(conversation) {
+        this.state.activeConversation = conversation;
+        this.state.lastConversation = conversation;
+    }
+    /** Records a conversation as the remembered fallback target only. */
+    observeConversation(conversation) {
+        this.state.lastConversation = conversation;
+    }
+    resolveTarget(fallback) {
+        return resolveConversationTarget({
+            active: this.state.activeConversation,
+            last: this.state.lastConversation,
+            fallback,
+        });
+    }
+    /**
+     * Busy-rejecting dispatch transaction: acquire the turn lease, forward the
+     * input, and roll the lease back when forwarding throws. A busy input runs
+     * `onBusy` (reminder) and returns without touching ownership.
+     */
+    async dispatch(params) {
+        const lease = this.beginTurn(params.task, params.conversation);
+        if (!lease) {
+            await params.onBusy?.();
+            return { status: "busy" };
+        }
+        try {
+            await params.forward();
+        }
+        catch (error) {
+            this.rollback(lease, {
+                restoreLastConversation: this.restoreLastConversationOnFailure,
+            });
+            throw error;
+        }
+        return { status: "dispatched", task: params.task };
+    }
+}

package/dist/daemon/daemon-link.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/daemon/emoji-bindings.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 { EMOJI_BINDINGS_FILE } from "../wechat/channel-config.js";
 import { t } from "../i18n/index.js";