@unlinearity/cli-wechat-bridge 1.1.5 → 1.1.6

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

@@ -1,17 +1,32 @@
 import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
-import { spawn as spawnChild } from "node:child_process";
-import { detectCliApproval, normalizeOutput, nowIso, truncatePreview, } from "./bridge-utils.js";
+import { spawn as spawnChild, spawnSync } from "node:child_process";
+import { detectCliApproval, } from "./bridge-utils.js";
+import { normalizeOutput, nowIso, summarizeOutput, truncatePreview, } from "../core/text-utils.js";
 import { AbstractPtyAdapter } from "./bridge-adapters.core.js";
 import { killProcessTreeSync } from "./bridge-process-reaper.js";
 import * as shared from "./bridge-adapters.shared.js";
 import { requestCodexVisibleThreadSwitch } from "../companion/codex-visible-client-link.js";
 import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
 import { CODEX_REMOTE_AUTH_TOKEN_ENV, LOCAL_CLIENT_PROTOCOL_VERSION, } from "../runtime/runtime-types.js";
+export function parseCodexCliVersion(output) {
+    const match = output.match(/\b(\d+\.\d+\.\d+)\b/);
+    return match?.[1] ?? null;
+}
+export function isCodexVersionInCompatibilityRange(version) {
+    const parts = version.split(".").map((part) => Number(part));
+    if (parts.length !== 3 || parts.some((part) => !Number.isInteger(part))) {
+        return false;
+    }
+    const major = parts[0] ?? -1;
+    const minor = parts[1] ?? -1;
+    return major === 0 && minor >= 149 && minor <= 151;
+}
 const { CODEX_APP_SERVER_HOST, CODEX_APP_SERVER_READY_TIMEOUT_MS, CODEX_FINAL_REPLY_SETTLE_DELAY_MS, CODEX_RECENT_SESSION_KEY_LIMIT, CODEX_RPC_CONNECT_RETRY_MS, CODEX_RPC_RECONNECT_TIMEOUT_MS, CODEX_SESSION_FALLBACK_SCAN_INTERVAL_MS, CODEX_SESSION_LOCAL_MIRROR_FALLBACK_WINDOW_MS, CODEX_SESSION_POLL_INTERVAL_MS, CODEX_STARTUP_WARMUP_MS, CODEX_THREAD_SIGNAL_TTL_MS, INTERRUPT_SETTLE_DELAY_MS, appendBoundedLog, buildCodexApprovalRequest, buildCodexCliArgs, buildCodexDynamicToolCallFailureResponse, buildCodexMcpServerElicitationDeclineResponse, buildCodexPermissionsRequestApprovalResponse, buildCodexUserInputRequest, coerceWebSocketMessageData, delay, describeUnknownError, extractCodexFinalTextFromItem, extractCodexThreadFollowIdFromStatusChanged, extractCodexThreadStartedThreadId, extractCodexUserMessageText, findCodexSessionFile, findRecentCodexSessionFileForCwd, getCodexRpcRequestId, getCodexApprovalAutoResponse, getCodexWechatOutboundAttachmentDenyMessage, getNotificationThreadId, getNotificationTurnId, isRecord, isRecentIsoTimestamp, listCodexResumeSessions, normalizeComparablePath, normalizeCodexRpcError, reserveLocalPort, resolveSpawnTarget, shouldAutoCompleteCodexWechatTurnAfterFinalReply, shouldIgnoreCodexSessionReplayEntry, shouldRecoverCodexStaleBusyState, waitForTcpPort, } = shared;
 const CODEX_LOCAL_THREAD_ANNOUNCE_SETTLE_MS = 150;
 const CODEX_NON_BLOCKING_USER_INPUT_TIMEOUT_MS = 120_000;
+const CODEX_RESUME_REPLAY_SETTLE_MS = 5_000;
 function getCodexThreadStatusType(value) {
     if (typeof value === "string") {
         return value;
@@ -69,8 +84,12 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     rpcRequestCounter = 0;
     pendingRpcRequests = new Map();
     subscribedThreadIds = new Set();
+    pendingThreadSubscriptions = new Map();
     sharedThreadId = null;
     announcedThreadId = null;
+    localThreadFollowBlockedUntilMs = 0;
+    pendingThreadStatusChecks = new Map();
+    threadStatusCheckEpoch = 0;
     pendingThreadAnnouncement = null;
     activeTurn = null;
     bridgeOwnedTurnIds = new Set();
@@ -80,6 +99,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     interruptPendingTurnStart = false;
     pendingThreadFollowId = null;
     pendingVisibleResume = null;
+    bridgeResumeReplayThreadId = null;
+    bridgeResumeReplayUntilMs = 0;
     pendingApprovalRequests = [];
     pendingUserInputRequest = null;
     pendingUserInputTimer = null;
@@ -108,6 +129,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     finalReplyCompletionTimer = null;
     finalReplyCompletionTurnId = null;
     resumeThreadId;
+    codexCliVersion = null;
     localClientInstanceId = `${process.pid}-${Date.now().toString(36)}`;
     constructor(options) {
         super(options);
@@ -126,6 +148,13 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (this.isHeadlessRuntimeMode()) {
             this.setStatus("starting", `Starting ${this.options.kind} runtime host...`);
         }
+        this.codexCliVersion = this.detectCodexCliVersion();
+        const compatibility = this.codexCliVersion
+            ? isCodexVersionInCompatibilityRange(this.codexCliVersion)
+                ? `compatible=${this.codexCliVersion}`
+                : `outside-supported-range=${this.codexCliVersion}`
+            : "unknown-version";
+        this.setStatus("starting", `Codex protocol compatibility: ${compatibility}.`);
         await this.startAppServer();
         await this.connectRpcClient();
         await this.restoreInitialSharedThreadIfNeeded();
@@ -406,6 +435,24 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         return this.isNativePanelMode() ? Boolean(this.nativeProcess) : Boolean(this.pty);
     }
+    detectCodexCliVersion() {
+        try {
+            const target = resolveSpawnTarget(this.options.command, "codex", {
+                forwardArgs: ["--version"],
+            });
+            const result = spawnSync(target.file, target.args, {
+                cwd: this.options.cwd,
+                env: this.buildEnv(),
+                encoding: "utf8",
+                timeout: 5_000,
+                windowsHide: true,
+            });
+            return parseCodexCliVersion(`${result.stdout ?? ""}\n${result.stderr ?? ""}`);
+        }
+        catch {
+            return null;
+        }
+    }
     shouldPollSessionLog() {
         return (this.isCodexClientRunning() ||
             this.pendingTurnStart ||
@@ -1335,13 +1382,18 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (this.subscribedThreadIds.has(threadId)) {
             return true;
         }
-        try {
-            await this.ensureSharedThreadSubscribed(threadId);
-            return true;
-        }
-        catch {
-            return false;
+        const pending = this.pendingThreadSubscriptions.get(threadId);
+        if (pending) {
+            return await pending;
         }
+        const attempt = this.ensureSharedThreadSubscribed(threadId)
+            .then(() => true)
+            .catch(() => false)
+            .finally(() => {
+            this.pendingThreadSubscriptions.delete(threadId);
+        });
+        this.pendingThreadSubscriptions.set(threadId, attempt);
+        return await attempt;
     }
     async ensureSharedThreadSubscribed(threadId) {
         if (this.subscribedThreadIds.has(threadId)) {
@@ -1359,11 +1411,12 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!resumedThreadId) {
             throw new Error("Codex did not return a thread id while subscribing the bridge client.");
         }
+        if (resumedThreadId !== threadId) {
+            throw new Error(`Codex opened ${resumedThreadId}, expected ${threadId}.`);
+        }
+        this.validateCodexThreadWorkspaceIfPresent(response, threadId);
         this.rememberBridgeOwnedThreadSignal(resumedThreadId);
         this.subscribedThreadIds.add(resumedThreadId);
-        if (resumedThreadId !== this.sharedThreadId) {
-            this.updateSharedThread(resumedThreadId);
-        }
     }
     async listAppServerResumeSessions(limit) {
         const boundedLimit = Math.max(1, Math.min(100, limit));
@@ -1415,6 +1468,25 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         return thread;
     }
+    validateCodexThreadWorkspaceIfPresent(response, targetThreadId) {
+        if (!isRecord(response) || !isRecord(response.thread)) {
+            return;
+        }
+        const thread = response.thread;
+        if (typeof thread.id === "string" && thread.id !== targetThreadId) {
+            throw new Error(`Codex opened ${thread.id}, expected ${targetThreadId}.`);
+        }
+        if (typeof thread.cwd === "string" &&
+            normalizeComparablePath(thread.cwd) !== normalizeComparablePath(this.options.cwd)) {
+            throw new Error(`Codex thread ${targetThreadId} does not belong to ${this.options.cwd}.`);
+        }
+        if (typeof thread.parentThreadId === "string") {
+            throw new Error(`Codex thread ${targetThreadId} is a subagent thread.`);
+        }
+        if (thread.ephemeral === true) {
+            throw new Error(`Codex thread ${targetThreadId} is ephemeral.`);
+        }
+    }
     async resumeVisibleSharedThread(threadId) {
         const targetThreadId = threadId.trim();
         if (!targetThreadId) {
@@ -1439,17 +1511,19 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (this.state.status !== "idle") {
             throw new Error(`Codex cannot switch threads while its status is ${this.state.status}.`);
         }
-        const readResponse = await this.sendRpcRequest("thread/read", {
-            threadId: targetThreadId,
-            includeTurns: false,
-        });
-        this.validateCodexResumeThread(readResponse, targetThreadId);
         const previousThreadId = this.sharedThreadId;
         let targetSubscribed = false;
         this.pendingVisibleResume = { targetThreadId };
-        this.setStatus("starting", `Switching Codex to thread ${targetThreadId.slice(0, 12)}...`);
+        this.setStatus("starting", `Codex resume validating thread ${targetThreadId.slice(0, 12)}...`);
         try {
+            const readResponse = await this.sendRpcRequest("thread/read", {
+                threadId: targetThreadId,
+                includeTurns: false,
+            });
+            this.validateCodexResumeThread(readResponse, targetThreadId);
+            this.setStatus("starting", `Codex resume validated thread ${targetThreadId.slice(0, 12)}.`);
             this.rememberBridgeOwnedThreadSignal(targetThreadId);
+            this.setStatus("starting", `Codex resume requesting thread ${targetThreadId.slice(0, 12)}.`);
             const resumeResponse = await this.sendRpcRequest("thread/resume", {
                 threadId: targetThreadId,
                 approvalPolicy: "on-request",
@@ -1460,6 +1534,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             targetSubscribed = true;
             this.validateCodexResumeThread(resumeResponse, targetThreadId);
             this.subscribedThreadIds.add(targetThreadId);
+            this.setStatus("starting", `Codex resume switching visible thread ${targetThreadId.slice(0, 12)}.`);
             const visibleThreadId = await this.switchVisibleCodexThread(targetThreadId);
             if (visibleThreadId !== targetThreadId) {
                 throw new Error(`The visible Codex client opened ${visibleThreadId}, expected ${targetThreadId}.`);
@@ -1474,6 +1549,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 reason: "wechat_resume",
                 notify: true,
             });
+            this.bridgeResumeReplayThreadId = targetThreadId;
+            this.bridgeResumeReplayUntilMs = Date.now() + CODEX_RESUME_REPLAY_SETTLE_MS;
+            this.setStatus("starting", `Codex resume committed thread ${targetThreadId.slice(0, 12)}.`);
             this.setStatus("idle");
             if (previousThreadId && previousThreadId !== targetThreadId) {
                 await this.unsubscribeCodexThreadBestEffort(previousThreadId);
@@ -1483,7 +1561,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             if (targetSubscribed && targetThreadId !== previousThreadId) {
                 await this.unsubscribeCodexThreadBestEffort(targetThreadId);
             }
-            this.setStatus("idle");
+            this.setStatus("idle", `Codex resume failed for ${targetThreadId.slice(0, 12)}: ${describeUnknownError(error)}`);
             throw error;
         }
         finally {
@@ -1533,6 +1611,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!resumedThreadId) {
             throw new Error("Codex did not return a thread id while resuming the saved thread.");
         }
+        this.validateCodexThreadWorkspaceIfPresent(response, resumedThreadId);
         this.rememberBridgeOwnedThreadSignal(resumedThreadId);
         this.subscribedThreadIds.add(resumedThreadId);
         this.sessionFilePath = null;
@@ -1680,6 +1759,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             this.completedTurnOrder = [];
         }
         this.pendingInjectedInputs = [];
+        this.threadStatusCheckEpoch += 1;
+        this.pendingThreadStatusChecks.clear();
+        this.clearBridgeResumeReplay();
         this.recentBridgeThreadSignalAtById.clear();
         this.sessionFinalText = null;
         this.nextSessionFallbackScanAtMs = 0;
@@ -1746,6 +1828,10 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             });
         }
     }
+    blockLateLocalThreadFollow() {
+        this.localThreadFollowBlockedUntilMs =
+            Date.now() + CODEX_LOCAL_THREAD_ANNOUNCE_SETTLE_MS;
+    }
     clearPendingThreadAnnouncement() {
         if (!this.pendingThreadAnnouncement) {
             return;
@@ -1804,16 +1890,29 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         pending.timer.unref?.();
     }
     trackLocalSharedThread(threadId, options) {
+        const weakSignal = options.signal === "status_changed" ||
+            options.signal === "thread_started" ||
+            options.signal === "session_fallback";
+        if (weakSignal && Date.now() < this.localThreadFollowBlockedUntilMs) {
+            return;
+        }
+        if (options.signal === "user_message" || options.signal === "turn_started") {
+            this.localThreadFollowBlockedUntilMs = 0;
+        }
         if (this.pendingVisibleResume) {
             return;
         }
         this.interruptWechatTurnForLocalThreadSwitch(threadId);
         if (!this.isNativePanelMode()) {
+            const threadChanged = this.sharedThreadId !== threadId;
             this.updateSharedThread(threadId, {
                 source: "local",
                 reason: options.reason,
                 notify: true,
             });
+            if (threadChanged) {
+                void this.tryEnsureSharedThreadSubscribed(threadId);
+            }
             return;
         }
         this.updateSharedThread(threadId, {
@@ -1897,6 +1996,20 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         return true;
     }
+    isBridgeResumeReplay(threadId) {
+        if (this.bridgeResumeReplayThreadId !== threadId) {
+            return false;
+        }
+        if (Date.now() >= this.bridgeResumeReplayUntilMs) {
+            this.clearBridgeResumeReplay();
+            return false;
+        }
+        return true;
+    }
+    clearBridgeResumeReplay() {
+        this.bridgeResumeReplayThreadId = null;
+        this.bridgeResumeReplayUntilMs = 0;
+    }
     clearPendingApprovalState() {
         this.pendingApprovalRequests = [];
         this.pendingApproval = null;
@@ -2393,6 +2506,68 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!threadId) {
             return;
         }
+        if (this.pendingVisibleResume) {
+            return;
+        }
+        if (this.isBridgeResumeReplay(threadId)) {
+            return;
+        }
+        const notificationCwd = typeof params.cwd === "string"
+            ? params.cwd
+            : isRecord(params.thread) && typeof params.thread.cwd === "string"
+                ? params.thread.cwd
+                : null;
+        if (notificationCwd &&
+            normalizeComparablePath(notificationCwd) !== normalizeComparablePath(this.options.cwd)) {
+            return;
+        }
+        if (!this.isTrustedThreadStatus(threadId, Boolean(notificationCwd))) {
+            this.queueThreadStatusCwdCheck(threadId);
+            return;
+        }
+        this.applyThreadStatusChanged(threadId);
+    }
+    isTrustedThreadStatus(threadId, hasCwd) {
+        if (hasCwd || this.isNativePanelMode()) {
+            return true;
+        }
+        return (this.subscribedThreadIds.has(threadId) ||
+            this.activeTurn?.threadId === threadId ||
+            this.pendingTurnThreadId === threadId ||
+            this.pendingVisibleResume?.targetThreadId === threadId);
+    }
+    queueThreadStatusCwdCheck(threadId) {
+        if (this.pendingThreadStatusChecks.has(threadId)) {
+            return;
+        }
+        const epoch = this.threadStatusCheckEpoch;
+        const check = this.sendRpcRequest("thread/read", {
+            threadId,
+            includeTurns: false,
+        })
+            .then((response) => {
+            if (epoch !== this.threadStatusCheckEpoch) {
+                return;
+            }
+            if (!isRecord(response) || !isRecord(response.thread)) {
+                return;
+            }
+            const thread = response.thread;
+            if (thread.id === threadId &&
+                typeof thread.cwd === "string" &&
+                normalizeComparablePath(thread.cwd) === normalizeComparablePath(this.options.cwd) &&
+                typeof thread.parentThreadId !== "string" &&
+                thread.ephemeral !== true) {
+                this.applyThreadStatusChanged(threadId);
+            }
+        })
+            .catch(() => undefined)
+            .finally(() => {
+            this.pendingThreadStatusChecks.delete(threadId);
+        });
+        this.pendingThreadStatusChecks.set(threadId, check);
+    }
+    applyThreadStatusChanged(threadId) {
         if (!this.activeTurn ||
             this.activeTurn.threadId === threadId ||
             this.activeTurn.origin === "wechat") {
@@ -2410,12 +2585,18 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!threadId) {
             return;
         }
+        if (this.isBridgeResumeReplay(threadId)) {
+            return;
+        }
         if (this.isRecentlyBridgeOwnedThread(threadId)) {
             return;
         }
         const thread = isRecord(params.thread) ? params.thread : null;
-        if (thread && typeof thread.cwd === "string") {
-            if (normalizeComparablePath(thread.cwd) !== normalizeComparablePath(this.options.cwd)) {
+        if (thread) {
+            if ((typeof thread.cwd === "string" &&
+                normalizeComparablePath(thread.cwd) !== normalizeComparablePath(this.options.cwd)) ||
+                typeof thread.parentThreadId === "string" ||
+                thread.ephemeral === true) {
                 return;
             }
         }
@@ -2435,6 +2616,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (this.activeTurn?.turnId === trackedTurn.turnId) {
             return;
         }
+        if (trackedTurn.origin === "local") {
+            this.clearBridgeResumeReplay();
+        }
         if (trackedTurn.origin === "local" &&
             trackedTurn.threadId !== this.sharedThreadId) {
             if (!this.activeTurn ||
@@ -2513,6 +2697,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (this.activeTurn?.turnId === trackedTurn.turnId) {
             this.setActiveTurn(null);
         }
+        if (completedTrackedTurn.origin === "wechat") {
+            this.blockLateLocalThreadFollow();
+        }
         this.cleanupTurnArtifacts(trackedTurn.turnId);
         if (this.state.status !== "stopped" &&
             (!this.activeTurn || this.activeTurn.turnId === trackedTurn.turnId)) {
@@ -2652,6 +2839,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!activeTurn || !finalText) {
             return;
         }
+        if (activeTurn.origin === "wechat") {
+            this.blockLateLocalThreadFollow();
+        }
         this.clearPendingApprovalState();
         this.clearPendingUserInputState();
         this.setActiveTurn(null);
@@ -2712,11 +2902,12 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.appServerAuthToken = null;
     }
     describeAppServerLog() {
-        const summary = normalizeOutput(this.appServerLog).trim();
-        if (!summary) {
+        const normalized = normalizeOutput(this.appServerLog).trim();
+        if (!normalized) {
             return "";
         }
-        return ` Recent app-server log: ${truncatePreview(summary, 220)}`;
+        const summary = summarizeOutput(normalized, 500);
+        return ` Recent app-server log: ${summary}`;
     }
     terminateCodexClient() {
         this.shuttingDown = true;

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

@@ -3,7 +3,8 @@ import path from "node:path";
 import { spawn as spawnPty } from "node-pty";
 import { t } from "../i18n/index.js";
 import { attachLocalCompanionMessageListener, buildLocalCompanionToken, clearLocalCompanionEndpoint, clearLocalCompanionOccupancy, sendLocalCompanionMessage, updateLocalCompanionOccupancy, writeLocalCompanionEndpoint, } from "../companion/local-companion-link.js";
-import { detectCliApproval, normalizeOutput, nowIso, truncatePreview, } from "./bridge-utils.js";
+import { detectCliApproval, } from "./bridge-utils.js";
+import { normalizeOutput, nowIso, truncatePreview } from "../core/text-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, buildSpawnDiagnostic, getLocalCompanionCommandName, getSharedSessionIdFromAdapterState, LOCAL_COMPANION_RECONNECT_GRACE_MS, resolveSpawnTarget, spawnFallbackProcess, } = shared;

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

@@ -7,7 +7,7 @@ import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { assertNoReservedExtraCliArgs, buildCliEnvironment, describeUnknownError, isRecord, resolveSpawnTarget, } from "./bridge-adapters.shared.js";
 import { killProcessTreeSync } from "./bridge-process-reaper.js";
-import { normalizeOutput, nowIso } from "./bridge-utils.js";
+import { normalizeOutput, nowIso } from "../core/text-utils.js";
 const PI_TUI_CONNECT_WARNING_MS = 30_000;
 const PI_TUI_REQUEST_TIMEOUT_MS = 30_000;
 const PI_TUI_RECONNECT_TIMEOUT_MS = 10_000;

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

@@ -6,7 +6,8 @@ import { fileURLToPath } from "node:url";
 import { spawn, spawnSync } from "node:child_process";
 import { t } from "../i18n/index.js";
 import { spawn as spawnPty } from "node-pty";
-import { WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE, containsWechatOutboundAttachmentPath, containsWechatOutboundAttachmentPathDeep, isWechatOutboundAttachmentWriteCommand, isHighRiskShellCommand, isStrictApprovalModeEnabled, normalizeOutput, truncatePreview, } from "./bridge-utils.js";
+import { WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE, containsWechatOutboundAttachmentPath, containsWechatOutboundAttachmentPathDeep, isWechatOutboundAttachmentWriteCommand, isHighRiskShellCommand, isStrictApprovalModeEnabled, } from "./bridge-utils.js";
+import { normalizeOutput, truncatePreview } from "../core/text-utils.js";
 import { getNotificationThreadId, isRecord, } from "./bridge-adapter-common.js";
 export { coerceWebSocketMessageData, describeUnknownError, getCodexRpcRequestId, getLocalCompanionCommandName, getNotificationThreadId, getNotificationTurnId, getSharedSessionIdFromAdapterState, isRecentIsoTimestamp, isRecord, normalizeCodexRpcError, quotePosixCommandArg, quoteWindowsCommandArg, } from "./bridge-adapter-common.js";
 export const DEFAULT_COLS = 120;

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

@@ -1,65 +1,2 @@
-import { formatFinalReplyMessage, parseWechatFinalReply, sanitizeWechatFinalReplyText, splitWechatTextIntoChunks, } from "./bridge-utils.js";
-export const OPENCODE_EMPTY_VISIBLE_REPLY_MESSAGE = "OpenCode 没有产生可发送到微信的可见回复。请查看本地终端输出，或重试这条消息。";
-export async function forwardWechatFinalReply(params) {
-    const { adapter, rawText, sender, onEmptyVisibleReply } = params;
-    const parsed = parseWechatFinalReply(rawText);
-    const sanitizedText = sanitizeWechatFinalReplyText(adapter, parsed.visibleText);
-    const visibleText = formatFinalReplyMessage(adapter, sanitizedText).trim();
-    if (visibleText) {
-        // Send long replies in bounded chunks: a single oversized sendmessage call
-        // can be rejected by the WeChat API, silently losing the whole reply.
-        const chunks = splitWechatTextIntoChunks(visibleText);
-        for (let index = 0; index < chunks.length; index += 1) {
-            const sent = await sender.sendText(chunks[index]);
-            if (sent === false) {
-                // The send channel is failing (e.g. an expired context token).
-                // Report what was dropped instead of ending mid-reply silently;
-                // this notice itself is best effort and may also fail.
-                const remainingChunks = chunks.length - index - 1;
-                if (remainingChunks > 0 || parsed.attachments.length > 0) {
-                    const parts = [];
-                    if (remainingChunks > 0) {
-                        parts.push(`${remainingChunks} reply chunk(s)`);
-                    }
-                    if (parsed.attachments.length > 0) {
-                        parts.push(`${parsed.attachments.length} attachment(s)`);
-                    }
-                    await sender.sendText(`[bridge] Reply delivery was interrupted; ${parts.join(" and ")} could not be sent. Send a new message to retry.`);
-                }
-                return;
-            }
-        }
-    }
-    else if (adapter === "opencode" && parsed.visibleText.trim()) {
-        onEmptyVisibleReply?.({
-            adapter,
-            rawVisibleText: parsed.visibleText,
-        });
-        const sent = await sender.sendText(OPENCODE_EMPTY_VISIBLE_REPLY_MESSAGE);
-        if (sent === false) {
-            return;
-        }
-    }
-    for (const attachment of parsed.attachments) {
-        try {
-            switch (attachment.kind) {
-                case "image":
-                    await sender.sendImage(attachment.path);
-                    break;
-                case "file":
-                    await sender.sendFile(attachment.path);
-                    break;
-                case "voice":
-                    await sender.sendVoice(attachment.path);
-                    break;
-                case "video":
-                    await sender.sendVideo(attachment.path);
-                    break;
-            }
-        }
-        catch (error) {
-            const errorText = error instanceof Error ? error.message : String(error ?? "unknown error");
-            await sender.sendText(`Failed to send ${attachment.kind} attachment: ${attachment.path}\n${errorText}`);
-        }
-    }
-}
+/** @deprecated Import from ../channels/wechat/bridge-final-reply.ts instead. */
+export * from "../channels/wechat/bridge-final-reply.js";

package/dist/bridge/bridge-state.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, appendBoundedLog, ensureWorkspaceChannelDir, ensureChannelDataDir, } from "../wechat/channel-config.js";
-import { buildInstanceId } from "./bridge-utils.js";
+import { buildInstanceId } from "../core/text-utils.js";
 import { writeJsonFileAtomic } from "../utils/atomic-file.js";
 import { getProcessRecordByPid, isWechatBridgeCommandLine, } from "./bridge-process-reaper.js";
 const ORPHAN_LOCK_RECLAIM_TIMEOUT_MS = 2_000;

package/dist/bridge/bridge-utils.js

@@ -1,9 +1,9 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-const ANSI_ESCAPE_RE = 
-// eslint-disable-next-line no-control-regex
-/\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+import { parseBridgeControlCommand, } from "../core/bridge-control.js";
+import { normalizeOutput, summarizeOutput, truncatePreview, } from "../core/text-utils.js";
+export { buildInstanceId, buildOneTimeCode, formatDuration, normalizeOutput, nowIso, stripAnsi, summarizeOutput, truncatePreview, } from "../core/text-utils.js";
 // Messages older than bridge start minus this grace window are treated as
 // pre-start backlog and skipped. The window must absorb realistic clock skew
 // between the local machine and WeChat server timestamps: with a small value,
@@ -99,29 +99,6 @@ const INLINE_REFERENCE_ONLY_FILE_EXTENSIONS = new Set([
 const INLINE_MAAS_URL_RE = /https?:\/\/[^\s]*?\/([A-Za-z]:\\.+?(?:\.\s*[A-Za-z0-9]{2,8})+)(?:\?[^\n]*)?/g;
 const INLINE_WINDOWS_PATH_RE = /(^|[^\w])`?([A-Za-z]:\\(?:[^\\/:*?"<>|\r\n`]+\\)*[^\\/:*?"<>|\r\n`]+?(?:\.\s*[A-Za-z0-9]{2,8})+)`?(?=$|[^\w])/gm;
 const INLINE_HOME_RELATIVE_PATH_RE = /(^|[^\w])`?((?:~[\\/])?(?:Desktop|Documents|Downloads|Pictures|Videos|Music)[\\/](?:[^\\/:*?"<>|\r\n`]+[\\/])*[^\\/:*?"<>|\r\n`]+?(?:\.\s*[A-Za-z0-9]{2,8})+)`?(?=$|[^\w])/gim;
-export function nowIso() {
-    return new Date().toISOString();
-}
-export function stripAnsi(text) {
-    return text.replace(ANSI_ESCAPE_RE, "");
-}
-export function normalizeOutput(text) {
-    return stripAnsi(text)
-        // eslint-disable-next-line no-control-regex
-        .replace(/\u0000/g, "")
-        .replace(/\r\n/g, "\n")
-        .replace(/\r/g, "\n");
-}
-export function truncatePreview(text, maxLength = 140) {
-    const normalized = normalizeOutput(text).trim().replace(/\s+/g, " ");
-    if (!normalized) {
-        return "(empty)";
-    }
-    if (normalized.length <= maxLength) {
-        return normalized;
-    }
-    return `${normalized.slice(0, Math.max(0, maxLength - 3))}...`;
-}
 export function isThinkingForwardEnabled() {
     if (process.env.CLI_BRIDGE_THINKING_FORWARD === "1") {
         return true;
@@ -150,51 +127,8 @@ export function formatThinkingForWechat(text, maxLength = 500) {
     }
     return `${normalized.slice(0, Math.max(0, maxLength - 3))}...`;
 }
-export function buildOneTimeCode(length = 6) {
-    const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
-    let code = "";
-    while (code.length < length) {
-        code += alphabet[Math.floor(Math.random() * alphabet.length)];
-    }
-    return code;
-}
-export function buildInstanceId() {
-    return `bridge-${Date.now().toString(36)}-${buildOneTimeCode(6).toLowerCase()}`;
-}
 export function parseSystemCommand(text) {
-    const trimmed = text.trim();
-    if (!trimmed.startsWith("/")) {
-        return null;
-    }
-    const [rawCommand, ...rest] = trimmed.split(/\s+/);
-    if (!rawCommand) {
-        return null;
-    }
-    const command = rawCommand.toLowerCase();
-    const argument = rest.join(" ").trim();
-    switch (command) {
-        case "/status":
-            return { type: "status" };
-        case "/resume":
-            return argument ? { type: "resume", target: argument } : { type: "resume" };
-        case "/new":
-        case "/new-session":
-            return { type: "new_session" };
-        case "/stop":
-            return { type: "stop" };
-        case "/reset":
-            return { type: "reset" };
-        case "/confirm":
-        case "/yes":
-            return { type: "confirm" };
-        case "/deny":
-        case "/no":
-            return { type: "deny" };
-        case "/answer":
-            return argument ? { type: "answer", raw: argument } : null;
-        default:
-            return null;
-    }
+    return parseBridgeControlCommand(text);
 }
 export function parseWechatControlCommand(text, options) {
     const systemCommand = parseSystemCommand(text);
@@ -474,32 +408,6 @@ export function detectCliApproval(text) {
         denyInput: matched.denyInput,
     };
 }
-export function formatDuration(durationMs) {
-    if (!Number.isFinite(durationMs) || durationMs < 0) {
-        return "0s";
-    }
-    const totalSeconds = Math.floor(durationMs / 1000);
-    const minutes = Math.floor(totalSeconds / 60);
-    const seconds = totalSeconds % 60;
-    if (!minutes) {
-        return `${seconds}s`;
-    }
-    return `${minutes}m ${seconds}s`;
-}
-export function summarizeOutput(text, maxLength = 280) {
-    const normalized = normalizeOutput(text)
-        .split("\n")
-        .map((line) => line.trim())
-        .filter(Boolean);
-    if (!normalized.length) {
-        return "(no output)";
-    }
-    const summary = normalized.slice(-6).join("\n");
-    if (summary.length <= maxLength) {
-        return summary;
-    }
-    return summary.slice(summary.length - maxLength);
-}
 export function formatStatusReport(bridgeState, adapterState) {
     const pending = bridgeState.pendingConfirmation;
     const pendingUserInput = bridgeState.pendingUserInput;