cli-wechat-bridge 1.1.8 → 1.2.1

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

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

package/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";

package/dist/core/bridge-control.js

@@ -34,6 +34,8 @@ export function parseBridgeControlCommand(text) {
             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

@@ -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 { AsyncLocalStorage } from "node:async_hooks";
 /**
  * Keeps the reply target scoped to one inbound async call chain. Different
@@ -19,6 +25,7 @@ export function tryBeginTurn(state, task, conversation) {
     const lease = {
         task,
         previousConversation: state.activeConversation,
+        previousLastConversation: state.lastConversation,
     };
     state.activeTask = task;
     if (conversation) {
@@ -27,12 +34,15 @@ export function tryBeginTurn(state, task, conversation) {
     }
     return lease;
 }
-export function rollbackTurn(state, 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) {

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";