@unlinearity/cli-wechat-bridge 1.0.3 → 1.0.5

package/bin/wechat-daemon.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runJsEntry } from "./_run-entry.mjs";
+
+runJsEntry("dist/daemon/wechat-daemon.js");

package/dist/bridge/bridge-adapter-common.js

@@ -0,0 +1,95 @@
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function getCodexRpcRequestId(value) {
+    return typeof value === "string" || typeof value === "number" ? value : null;
+}
+export function getNotificationThreadId(params) {
+    if (!isRecord(params)) {
+        return null;
+    }
+    if (typeof params.threadId === "string") {
+        return params.threadId;
+    }
+    if (isRecord(params.thread) && typeof params.thread.id === "string") {
+        return params.thread.id;
+    }
+    return null;
+}
+export function getNotificationTurnId(params) {
+    if (!isRecord(params)) {
+        return null;
+    }
+    if (typeof params.turnId === "string") {
+        return params.turnId;
+    }
+    if (isRecord(params.turn) && typeof params.turn.id === "string") {
+        return params.turn.id;
+    }
+    return null;
+}
+export function describeUnknownError(error) {
+    if (error instanceof Error && error.message) {
+        return error.message;
+    }
+    return String(error);
+}
+export function normalizeCodexRpcError(error) {
+    if (isRecord(error)) {
+        const message = typeof error.message === "string"
+            ? error.message
+            : typeof error.code === "number"
+                ? `RPC error ${error.code}`
+                : "";
+        const data = typeof error.data === "string"
+            ? error.data
+            : typeof error.details === "string"
+                ? error.details
+                : "";
+        const combined = [message, data].filter(Boolean).join(": ");
+        if (combined) {
+            return combined;
+        }
+    }
+    return describeUnknownError(error);
+}
+export function getLocalCompanionCommandName(kind) {
+    switch (kind) {
+        case "codex":
+            return "wechat-codex";
+        case "claude":
+            return "wechat-claude";
+        case "opencode":
+            return "wechat-opencode";
+        default:
+            return "local companion";
+    }
+}
+export function getSharedSessionIdFromAdapterState(state) {
+    return state.sharedSessionId ?? state.sharedThreadId;
+}
+export function quoteWindowsCommandArg(value) {
+    return `"${value.replace(/"/g, '""')}"`;
+}
+export function quotePosixCommandArg(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+export function isRecentIsoTimestamp(timestamp, maxAgeMs) {
+    const parsedMs = Date.parse(timestamp);
+    if (!Number.isFinite(parsedMs)) {
+        return false;
+    }
+    return parsedMs >= Date.now() - maxAgeMs;
+}
+export function coerceWebSocketMessageData(data) {
+    if (typeof data === "string") {
+        return data;
+    }
+    if (data instanceof ArrayBuffer) {
+        return Buffer.from(data).toString("utf8");
+    }
+    if (ArrayBuffer.isView(data)) {
+        return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8");
+    }
+    return null;
+}

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

@@ -7,7 +7,7 @@ import { buildClaudeFailureMessage, buildClaudeHookScript, buildClaudeHookSettin
 import { detectCliApproval, normalizeOutput, nowIso, truncatePreview, } from "./bridge-utils.js";
 import { AbstractPtyAdapter } from "./bridge-adapters.core.js";
 import * as shared from "./bridge-adapters.shared.js";
-const { CLAUDE_HOOK_LISTEN_HOST, CLAUDE_WECHAT_WORKING_NOTICE_DELAY_MS, MODULE_DIR, buildClaudeCliArgs, isClaudeInvalidResumeError, quotePosixCommandArg, quoteWindowsCommandArg, shouldIncludeClaudeNoAltScreen, } = shared;
+const { CLAUDE_HOOK_LISTEN_HOST, CLAUDE_WECHAT_WORKING_NOTICE_DELAY_MS, DEFAULT_COLS, DEFAULT_ROWS, MODULE_DIR, buildClaudeCliArgs, isClaudeInvalidResumeError, quotePosixCommandArg, quoteWindowsCommandArg, shouldIncludeClaudeNoAltScreen, } = shared;
 const CLAUDE_COMPACT_OUTPUT_LINE_RE = /^Compacted(?:\s*\(.*full summary.*\))?$/i;
 const CLAUDE_COMPACT_FAILURE_RE = /Error:\s*Error during compaction:|(?:^|\b)API Error:|\b(?:compact|compaction)\s+failed\b|^Error:/i;
 const CLAUDE_COMPACT_DEDUP_MS = 2_000;

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

@@ -469,6 +469,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             }
             this.sessionReadOffset = 0;
             this.sessionPartialLine = "";
+            this.seedSessionReplayCutoff(startedAtMs);
         }
         let content;
         try {
@@ -495,6 +496,17 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             this.handleSessionLogLine(line);
         }
     }
+    seedSessionReplayCutoff(startedAtMs) {
+        if (this.sessionIgnoreBeforeMs !== null ||
+            this.pendingTurnStart ||
+            this.activeTurn ||
+            this.state.activeTurnId) {
+            return;
+        }
+        if (Number.isFinite(startedAtMs)) {
+            this.sessionIgnoreBeforeMs = startedAtMs;
+        }
+    }
     maybeApplyRecentSessionFallback() {
         if (!this.isNativePanelMode()) {
             return;
@@ -538,6 +550,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             this.sessionReadOffset = 0;
             this.sessionPartialLine = "";
             this.sessionFinalText = null;
+            this.seedSessionReplayCutoff(startedAtMs);
         }
     }
     handleSessionLogLine(line) {
@@ -790,7 +803,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             this.pendingTurnThreadId = null;
             this.interruptPendingTurnStart = false;
             this.state.activeTurnOrigin = undefined;
-            if (!this.activeTurn && this.state.status === "busy") {
+            if (!this.activeTurn && this.getState().status === "busy") {
                 this.setStatus("idle");
             }
             throw error;
@@ -886,7 +899,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         catch (err) {
             await this.stopAppServer();
             const details = this.describeAppServerLog();
-            throw new Error(`Failed to start Codex app-server: ${String(err)}${details}`);
+            throw new Error(`Failed to start Codex app-server: ${String(err)}${details}`, {
+                cause: err,
+            });
         }
     }
     async connectRpcClient() {
@@ -1982,7 +1997,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (deltaFallback.length === 0) {
             return null;
         }
-        return deltaFallback[deltaFallback.length - 1];
+        return deltaFallback[deltaFallback.length - 1] ?? null;
     }
     recordTurnActivity(turnId, timestamp = Date.now()) {
         const timestampMs = typeof timestamp === "number" ? timestamp : Date.parse(timestamp);

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

@@ -3,6 +3,7 @@ import { spawn as spawnPty } from "node-pty";
 import { attachLocalCompanionMessageListener, buildLocalCompanionToken, clearLocalCompanionEndpoint, clearLocalCompanionOccupancy, sendLocalCompanionMessage, updateLocalCompanionOccupancy, writeLocalCompanionEndpoint, } from "../companion/local-companion-link.js";
 import { detectCliApproval, normalizeOutput, nowIso, truncatePreview, } from "./bridge-utils.js";
 import * as shared from "./bridge-adapters.shared.js";
+import { LOCAL_CLIENT_PROTOCOL_VERSION } from "../runtime/runtime-types.js";
 const { CODEX_APP_SERVER_HOST, INTERRUPT_SETTLE_DELAY_MS, buildCliEnvironment, buildPtySpawnOptions, getLocalCompanionCommandName, getSharedSessionIdFromAdapterState, LOCAL_COMPANION_RECONNECT_GRACE_MS, resolveSpawnTarget, } = shared;
 export class LocalCompanionProxyAdapter {
     options;
@@ -46,7 +47,10 @@ export class LocalCompanionProxyAdapter {
         this.shuttingDown = false;
         this.expectedCloseReason = null;
         this.clearReconnectShutdownTimer();
-        this.setStatus("starting", `Waiting for manual ${this.options.kind} companion connection. Run "${getLocalCompanionCommandName(this.options.kind)}" in a second terminal for this directory.`);
+        this.setStatus("starting", formatLocalCompanionStartupMessage({
+            kind: this.options.kind,
+            launchMode: this.options.companionLaunchMode,
+        }));
         await new Promise((resolve, reject) => {
             const server = net.createServer((socket) => {
                 this.handlePanelSocket(socket);
@@ -62,6 +66,8 @@ export class LocalCompanionProxyAdapter {
                     return;
                 }
                 this.endpoint = {
+                    protocolVersion: LOCAL_CLIENT_PROTOCOL_VERSION,
+                    runtimeKind: "legacy_adapter",
                     instanceId: `${process.pid}-${Date.now().toString(36)}`,
                     kind: this.options.kind,
                     port: address.port,
@@ -74,7 +80,8 @@ export class LocalCompanionProxyAdapter {
                     transcriptPath: this.state.transcriptPath,
                     startedAt: nowIso(),
                 };
-                writeLocalCompanionEndpoint(this.endpoint);
+                const endpoint = this.endpoint;
+                writeLocalCompanionEndpoint(endpoint);
                 resolve();
             });
         });
@@ -129,7 +136,9 @@ export class LocalCompanionProxyAdapter {
         this.expectedCloseReason = null;
         this.clearReconnectShutdownTimer();
         this.rejectPendingRequests(`${this.options.kind} companion proxy is shutting down.`);
-        clearLocalCompanionEndpoint(this.options.cwd, this.endpoint?.instanceId);
+        clearLocalCompanionEndpoint(this.options.cwd, this.endpoint?.instanceId, {
+            adapter: this.options.kind,
+        });
         if (this.socket) {
             try {
                 sendLocalCompanionMessage(this.socket, {
@@ -181,10 +190,15 @@ export class LocalCompanionProxyAdapter {
                 this.expectedCloseReason = null;
                 this.socket = socket;
                 this.detachMessageListener = detachListener;
+                const companionConnectedAt = nowIso();
+                if (this.endpoint) {
+                    this.endpoint.companionPid = message.companionPid;
+                    this.endpoint.companionConnectedAt = companionConnectedAt;
+                }
                 updateLocalCompanionOccupancy(this.options.cwd, {
                     companionPid: message.companionPid,
-                    companionConnectedAt: nowIso(),
-                }, this.endpoint?.instanceId);
+                    companionConnectedAt,
+                }, this.endpoint?.instanceId, { adapter: this.options.kind });
                 sendLocalCompanionMessage(socket, { type: "hello_ack" });
                 return;
             }
@@ -194,7 +208,9 @@ export class LocalCompanionProxyAdapter {
             if (this.socket === socket) {
                 const expectedCloseReason = this.expectedCloseReason;
                 this.expectedCloseReason = null;
-                clearLocalCompanionOccupancy(this.options.cwd, this.endpoint?.instanceId);
+                clearLocalCompanionOccupancy(this.options.cwd, this.endpoint?.instanceId, {
+                    adapter: this.options.kind,
+                });
                 this.detachPanelSocket();
                 if (!this.shuttingDown) {
                     this.handleCompanionDisconnect(expectedCloseReason);
@@ -292,6 +308,7 @@ export class LocalCompanionProxyAdapter {
             lifecycle: this.options.lifecycle,
             expectedClose: isExpectedLocalCompanionClose(expectedCloseReason),
             reconnectGraceMs: LOCAL_COMPANION_RECONNECT_GRACE_MS,
+            launchMode: this.options.companionLaunchMode,
         });
         if (disposition.action === "shutdown") {
             this.clearReconnectShutdownTimer();
@@ -358,7 +375,10 @@ export class LocalCompanionProxyAdapter {
     async sendRequest(payload) {
         const socket = this.socket;
         if (!socket) {
-            throw new Error(`${this.options.kind} companion is not connected. Run "${getLocalCompanionCommandName(this.options.kind)}" in a second terminal for this directory.`);
+            throw new Error(formatCompanionNotConnectedMessage({
+                kind: this.options.kind,
+                launchMode: this.options.companionLaunchMode,
+            }));
         }
         if (!this.state.pid && payload.command !== "dispose") {
             throw new Error(`${this.options.kind} companion is connected but not ready yet. Wait for it to finish starting.`);
@@ -385,6 +405,18 @@ export function buildCompanionHealthPatch(state, timestamp) {
         companionWorkerPid: state.pid,
     };
 }
+export function formatLocalCompanionStartupMessage(params) {
+    if (params.launchMode === "daemon_auto") {
+        return `Waiting for daemon-managed ${params.kind} companion connection. The daemon will open or reuse the visible CLI automatically.`;
+    }
+    return `Waiting for manual ${params.kind} companion connection. Run "${getLocalCompanionCommandName(params.kind)}" in a second terminal for this directory.`;
+}
+export function formatCompanionNotConnectedMessage(params) {
+    if (params.launchMode === "daemon_auto") {
+        return `${params.kind} companion is not connected yet. Send /${params.kind} in WeChat to open or reconnect the visible CLI automatically.`;
+    }
+    return `${params.kind} companion is not connected. Run "${getLocalCompanionCommandName(params.kind)}" in a second terminal for this directory.`;
+}
 export function isExpectedLocalCompanionClose(reason) {
     return typeof reason === "string" && reason.length > 0;
 }
@@ -407,11 +439,23 @@ export function getCompanionDisconnectDisposition(params) {
         };
     }
     if (params.expectedClose) {
+        if (params.launchMode === "daemon_auto") {
+            return {
+                action: "await_manual_reconnect",
+                message: `${params.kind} companion closed. Send /${params.kind} in WeChat to reopen the visible CLI automatically.`,
+            };
+        }
         return {
             action: "await_manual_reconnect",
             message: `${params.kind} companion closed. Run "${commandName}" again in a second terminal for this directory.`,
         };
     }
+    if (params.launchMode === "daemon_auto") {
+        return {
+            action: "await_manual_reconnect",
+            message: `${params.kind} companion disconnected unexpectedly. Send /${params.kind} in WeChat to reopen the visible CLI automatically.`,
+        };
+    }
     return {
         action: "await_manual_reconnect",
         message: `${params.kind} companion disconnected unexpectedly. Run "${commandName}" again in a second terminal for this directory to reconnect.`,