cli-wechat-bridge 1.1.0 → 1.1.2

package/README.md

@@ -7,11 +7,12 @@
 <p align="center">
   <a href="https://github.com/UNLINEARITY/CLI-WeChat-Bridge"><img alt="GitHub stars" src="https://img.shields.io/github/stars/UNLINEARITY/CLI-WeChat-Bridge?label=Stars&amp;style=for-the-badge&amp;logo=github&amp;color=0891b2&amp;labelColor=1c1917"></a>
   <a href="https://www.npmjs.com/package/cli-wechat-bridge"><img alt="npm version" src="https://img.shields.io/npm/v/cli-wechat-bridge?label=npm&amp;style=for-the-badge&amp;logo=npm&amp;color=cb3837&amp;labelColor=1c1917"></a>
-  <a href="https://www.npmjs.com/package/cli-wechat-bridge"><img alt="npm downloads" src="https://img.shields.io/npm/dm/cli-wechat-bridge?label=Downloads&amp;style=for-the-badge&amp;logo=npm&amp;color=16a34a&amp;labelColor=1c1917"></a>
-  <a href="https://www.npmjs.com/package/@unlinearity/cli-wechat-bridge"><img alt="scoped npm downloads" src="https://img.shields.io/npm/dm/@unlinearity/cli-wechat-bridge?label=Scoped%20downloads&amp;style=for-the-badge&amp;logo=npm&amp;color=15803d&amp;labelColor=1c1917"></a>
+  <a href="https://www.npmjs.com/package/cli-wechat-bridge"><img alt="npm downloads" src="https://img.shields.io/npm/dt/cli-wechat-bridge?label=Downloads&amp;style=for-the-badge&amp;logo=npm&amp;color=16a34a&amp;labelColor=1c1917"></a>
+  <a href="https://www.npmjs.com/package/@unlinearity/cli-wechat-bridge"><img alt="scoped npm downloads" src="https://img.shields.io/npm/dt/@unlinearity/cli-wechat-bridge?label=Scoped%20downloads&amp;style=for-the-badge&amp;logo=npm&amp;color=15803d&amp;labelColor=1c1917"></a>
   <a href="https://www.npmjs.com/package/cli-wechat-bridge">
   <img alt="License" src="https://img.shields.io/badge/License-AGPL--3.0-7c3aed?style=for-the-badge&labelColor=1c1917">
 </a>
+  <a href="https://github.com/UNLINEARITY/CLI-WeChat-Bridge/actions/workflows/ci.yml"><img alt="CI" src="https://img.shields.io/github/actions/workflow/status/UNLINEARITY/CLI-WeChat-Bridge/ci.yml?branch=main&label=CI&style=for-the-badge&logo=githubactions&logoColor=white&labelColor=1c1917"></a>
 </p>
 
 **命令行工具的微信桥接**：本项目将微信消息桥接到本地运行的 [`Codex`](https://github.com/openai/codex)、[`Claude Code`](https://code.claude.com/docs/en/overview) 和 [`OpenCode`](https://github.com/anomalyco/opencode)，同时把本地输出、审批请求与运行状态同步回微信。
@@ -26,6 +27,7 @@
 - [运行配置](docs/configuration.md)：数据目录、上传大小限制、调试开关等环境变量。
 - [开发说明](docs/development.md)：源码运行、测试、构建、打包和全局 smoke 验证。
 - [发布说明](docs/releases/README.md)：各版本变更与升级说明。
+- [通信架构](docs/architecture.md)：三种 CLI 适配器的通信机制、PTY 依赖分析和技术决策。
 
 ## 这个项目解决什么问题？
 
@@ -63,6 +65,35 @@ npm install -g cli-wechat-bridge@latest
 
 兼容性说明：旧包名 `@unlinearity/cli-wechat-bridge` 会继续同步发布，已经安装旧包名的用户可以正常升级；新用户优先使用更短的 `cli-wechat-bridge`。
 
+<details>
+<summary><b>安装遇到问题？（node-pty 原生模块）</b></summary>
+
+本项目使用 `node-pty` 为 CLI 适配器提供完整终端模拟。**Claude Code 适配器当前通过 PTY 交互模式工作**，node-pty 不可用时会回退到兼容模式，但 Claude Code 在此模式下可能无法正常桥接；Codex 适配器主要通过 WebSocket RPC 通信，通常不受影响；OpenCode 适配器完全不依赖 node-pty。
+
+**Linux 用户**（最常见）：需要原生模块编译工具：
+
+```bash
+# Debian / Ubuntu
+sudo apt install build-essential python3
+# RHEL / Fedora
+sudo dnf groupinstall "Development Tools" && sudo dnf install python3
+# Alpine
+apk add build-base python3
+```
+
+安装编译工具后重新安装：`npm install -g cli-wechat-bridge@latest`
+
+**macOS 用户**：如遇编译问题，安装 Xcode 命令行工具：`xcode-select --install`
+
+**Windows 用户**：
+- 需要 Windows 10 1809（build 18309）或更高版本
+- 如果 node-pty 加载失败，运行 `npm rebuild node-pty` 或重新安装
+- 确保已安装 [Visual C++ Redistributable](https://aka.ms/vs/17/release/vc_redist.x64.exe)
+
+运行 `wechat-daemon --doctor` 可快速检查环境状态。详见 [问题排查](docs/troubleshooting.md#pty-不可用--回退模式)。
+
+</details>
+
 ### 3. 完成微信登录
 
 全局安装后运行：

package/bin/_run-entry.mjs

@@ -6,8 +6,32 @@ import { fileURLToPath } from "node:url";
 
 const BIN_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PROJECT_DIR = path.resolve(BIN_DIR, "..");
+const MIN_NODE_MAJOR = 24;
+
+function ensureSupportedNodeVersion() {
+  if (process.env.CLI_BRIDGE_SKIP_NODE_CHECK === "1") {
+    return;
+  }
+
+  const major = Number(process.versions.node.split(".")[0]);
+  if (Number.isFinite(major) && major >= MIN_NODE_MAJOR) {
+    return;
+  }
+
+  process.stderr.write(
+    [
+      `[cli-wechat-bridge] Node.js >= ${MIN_NODE_MAJOR} is required, but you are running ${process.version}.`,
+      `[cli-wechat-bridge] 需要 Node.js >= ${MIN_NODE_MAJOR}，当前版本为 ${process.version}。`,
+      "Install the latest LTS from https://nodejs.org/ (or via nvm), then retry.",
+      "Set CLI_BRIDGE_SKIP_NODE_CHECK=1 to bypass this check at your own risk.",
+      "",
+    ].join("\n"),
+  );
+  process.exit(1);
+}
 
 export function runJsEntry(relativeEntryPath, extraArgs = []) {
+  ensureSupportedNodeVersion();
   const entryPath = path.join(PROJECT_DIR, relativeEntryPath);
   const child = spawn(
     process.execPath,

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

@@ -393,6 +393,14 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
                 socket.setEncoding("utf8");
                 socket.on("data", (chunk) => {
                     buffer += chunk;
+                    // Cap the buffer: a single hook frame is tiny, so a frame larger
+                    // than 1 MiB means a misbehaving client (e.g. one that never sends a
+                    // newline). Without this the buffer could grow unbounded. Sibling
+                    // IPC paths already cap their buffers; this one did not.
+                    if (buffer.length > 1024 * 1024) {
+                        socket.destroy();
+                        return;
+                    }
                     while (true) {
                         const newlineIndex = buffer.indexOf("\n");
                         if (newlineIndex < 0) {
@@ -903,6 +911,16 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         try {
             await super.reset();
         }
+        catch (error) {
+            // recoverFromInvalidResume is invoked fire-and-forget (void) and there is
+            // no global unhandled-rejection handler, so a throwing reset() must be
+            // caught here to avoid crashing the bridge.
+            this.emit({
+                type: "fatal_error",
+                message: `Failed to restart Claude after invalid resume: ${String(error)}`,
+                timestamp: nowIso(),
+            });
+        }
         finally {
             this.recoveringInvalidResume = false;
         }

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

@@ -937,6 +937,31 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         child.stderr.on("data", (chunk) => {
             this.appServerLog = appendBoundedLog(this.appServerLog, chunk);
         });
+        child.once("error", (error) => {
+            // spawn itself failed (ENOENT/EACCES/EMFILE). Without this listener the
+            // 'error' event is unhandled and crashes the bridge. Mirror the exit
+            // handler's cleanup so the failure surfaces as a fatal_error instead.
+            const expectedShutdown = shouldSuppressCodexTransportFatalError({
+                transportShuttingDown: this.appServerShuttingDown,
+                shuttingDown: this.shuttingDown,
+                cleanPanelExitInProgress: this.cleanPanelExitInProgress,
+            });
+            this.appServer = null;
+            this.appServerPort = null;
+            this.appServerShuttingDown = false;
+            this.deleteAppServerAuthTokenFile();
+            this.appServerAuthToken = null;
+            if (expectedShutdown) {
+                return;
+            }
+            const details = this.describeAppServerLog();
+            this.emit({
+                type: "fatal_error",
+                message: `codex app-server failed to start: ${String(error)}${details}`,
+                timestamp: nowIso(),
+            });
+            this.terminateCodexClient();
+        });
         child.on("exit", (code, signal) => {
             const expectedShutdown = shouldSuppressCodexTransportFatalError({
                 transportShuttingDown: this.appServerShuttingDown,

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

@@ -31,6 +31,11 @@ export class OpenCodeServerAdapter {
     workingNoticeTimer = null;
     workingNoticeSent = false;
     lastBusyAtMs = 0;
+    // Monotonic token bumped on every beginTrackedTurn. Lets a deferred turn
+    // completion (.then in handleSessionIdle) detect that a newer turn started
+    // while it was awaiting, so the stale completion becomes a no-op instead of
+    // clobbering the in-flight turn (stale final_reply / status flip / batcher clear).
+    currentTurnToken = 0;
     pendingLocalPrompt = "";
     localPromptNoticeSent = false;
     loggedUnknownEventTypes = new Set();
@@ -773,10 +778,21 @@ export class OpenCodeServerAdapter {
             this.hasAcceptedInput = false;
             const completedPreview = this.currentPreview;
             const turnStartedAtMs = this.lastBusyAtMs;
+            const completingTurnToken = this.currentTurnToken;
             void this.outputBatcher.flushNow()
                 .catch(() => undefined)
                 .then(async () => {
+                // A newer turn (local or wechat) may have started while we awaited
+                // the flush. If so, this completion is stale: dropping it avoids
+                // flipping the active turn back to idle, emitting the old final_reply,
+                // and clearing the new turn's buffered output.
+                if (this.currentTurnToken !== completingTurnToken) {
+                    return;
+                }
                 const finalReplyText = await this.resolveFinalReplyText(sessionId, turnStartedAtMs);
+                if (this.currentTurnToken !== completingTurnToken) {
+                    return;
+                }
                 this.setStatus("idle");
                 if (finalReplyText) {
                     this.emit({
@@ -1618,6 +1634,7 @@ export class OpenCodeServerAdapter {
         return session;
     }
     beginTrackedTurn(text, origin, options = {}) {
+        this.currentTurnToken += 1;
         this.hasAcceptedInput = true;
         this.currentPreview = truncatePreview(text);
         this.state.lastInputAt = nowIso();

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

@@ -1,11 +1,12 @@
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import net from "node:net";
 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, normalizeOutput, truncatePreview, } from "./bridge-utils.js";
+import { WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE, containsWechatOutboundAttachmentPath, containsWechatOutboundAttachmentPathDeep, isWechatOutboundAttachmentWriteCommand, isHighRiskShellCommand, isStrictApprovalModeEnabled, normalizeOutput, truncatePreview, } from "./bridge-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;
@@ -250,7 +251,10 @@ function containsHighRiskPermissionTarget(value) {
     collectPermissionPaths(value, paths);
     return paths.some(isHighRiskPermissionPath);
 }
-export function getCodexApprovalAutoResponse(method, params) {
+export function getCodexApprovalAutoResponse(method, params, env = process.env) {
+    if (isStrictApprovalModeEnabled(env)) {
+        return null;
+    }
     if (method === "item/commandExecution/requestApproval") {
         const command = typeof params.command === "string" ? params.command : "";
         if (!commandApprovalAllowsAccept(params.availableDecisions)) {
@@ -688,49 +692,16 @@ export function buildCliEnvironment(kind, options = {}) {
     const sourceEnv = options.env ?? process.env;
     const platform = options.platform ?? process.platform;
     if (kind === "codex" || kind === "claude" || kind === "opencode") {
-        if (platform !== "win32") {
-            return applyLoopbackNoProxy({
-                ...copyDefinedEnv(sourceEnv),
-                TERM: sourceEnv.TERM || "xterm-256color",
-            });
-        }
+        // Pass the full environment through on every platform. A previous
+        // Windows-only allowlist silently dropped user-configured variables such
+        // as ANTHROPIC_BASE_URL / ANTHROPIC_AUTH_TOKEN / OPENAI_API_KEY, which
+        // broke CLIs that authenticate via environment variables even though the
+        // same CLI worked when launched manually from the user's shell.
         const env = {
+            ...copyDefinedEnv(sourceEnv),
             TERM: sourceEnv.TERM || "xterm-256color",
         };
-        const keys = [
-            "PATH",
-            "PATHEXT",
-            "ComSpec",
-            "COMSPEC",
-            "SystemRoot",
-            "SYSTEMROOT",
-            "USERPROFILE",
-            "HOME",
-            "APPDATA",
-            "LOCALAPPDATA",
-            "TEMP",
-            "TMP",
-            "OS",
-            "ProgramFiles",
-            "ProgramFiles(x86)",
-            "CommonProgramFiles",
-            "CommonProgramFiles(x86)",
-            "HTTP_PROXY",
-            "HTTPS_PROXY",
-            "ALL_PROXY",
-            "http_proxy",
-            "https_proxy",
-            "all_proxy",
-            "NO_PROXY",
-            "no_proxy",
-        ];
-        for (const key of keys) {
-            const value = sourceEnv[key];
-            if (value) {
-                env[key] = value;
-            }
-        }
-        if (!env.HOME && env.USERPROFILE) {
+        if (platform === "win32" && !env.HOME && env.USERPROFILE) {
             env.HOME = env.USERPROFILE;
         }
         return applyLoopbackNoProxy(env);
@@ -740,6 +711,13 @@ export function buildCliEnvironment(kind, options = {}) {
         TERM: sourceEnv.TERM || "xterm-256color",
     };
 }
+// ConPTY shipped in Windows 10 build 18309; on older builds node-pty must be
+// left to auto-select its winpty fallback instead of being forced onto ConPTY.
+export const WINDOWS_CONPTY_MIN_BUILD = 18309;
+export function windowsBuildSupportsConpty(osRelease) {
+    const build = Number(osRelease.split(".")[2]);
+    return Number.isFinite(build) && build >= WINDOWS_CONPTY_MIN_BUILD;
+}
 export function buildPtySpawnOptions(params) {
     const options = {
         name: "xterm-color",
@@ -748,7 +726,8 @@ export function buildPtySpawnOptions(params) {
         cwd: params.cwd,
         env: params.env,
     };
-    if ((params.platform ?? process.platform) === "win32") {
+    if ((params.platform ?? process.platform) === "win32" &&
+        windowsBuildSupportsConpty(params.osRelease ?? os.release())) {
         options.useConpty = true;
     }
     return options;
@@ -1246,6 +1225,18 @@ export function spawnFallbackProcess(file, args, options) {
             listener({ exitCode });
         }
     });
+    // spawn itself failed (e.g. ENOENT/EACCES) — surface as an exit so callers
+    // stop waiting, instead of throwing an unhandled "error" event that would
+    // crash the bridge on the PTY fallback path.
+    child.on("error", () => {
+        for (const listener of exitListeners) {
+            listener({ exitCode: 1 });
+        }
+    });
+    // Swallow broken-pipe errors on stdin writes after the child has exited.
+    child.stdin?.on("error", () => {
+        /* best effort */
+    });
     return {
         pid: child.pid,
         write(data) {
@@ -1301,6 +1292,9 @@ export function buildSpawnDiagnostic(error, spawnTarget, platform = process.plat
         if (platform === "darwin") {
             lines.push(t("spawn.diagnostic.xcode"));
         }
+        if (platform === "linux") {
+            lines.push(t("spawn.diagnostic.linuxBuildTools"));
+        }
     }
     else if (errorMessage.includes("ENOENT") || errorMessage.includes("spawn")) {
         lines.push(t("spawn.diagnostic.notFound", { target }));
@@ -1310,7 +1304,7 @@ export function buildSpawnDiagnostic(error, spawnTarget, platform = process.plat
     }
     lines.push(t("spawn.diagnostic.nodeVersion"));
     if (platform === "win32") {
-        lines.push(t("spawn.diagnostic.winAdmin"));
+        lines.push(t("spawn.diagnostic.winFull"));
     }
     return lines.join("\n");
 }

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

@@ -1,4 +1,4 @@
-import { formatFinalReplyMessage, parseWechatFinalReply, sanitizeWechatFinalReplyText, } from "./bridge-utils.js";
+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;
@@ -6,9 +6,13 @@ export async function forwardWechatFinalReply(params) {
     const sanitizedText = sanitizeWechatFinalReplyText(adapter, parsed.visibleText);
     const visibleText = formatFinalReplyMessage(adapter, sanitizedText).trim();
     if (visibleText) {
-        const sent = await sender.sendText(visibleText);
-        if (sent === false) {
-            return;
+        // Send long replies in bounded chunks: a single oversized sendmessage call
+        // can be rejected by the WeChat API, silently losing the whole reply.
+        for (const chunk of splitWechatTextIntoChunks(visibleText)) {
+            const sent = await sender.sendText(chunk);
+            if (sent === false) {
+                return;
+            }
         }
     }
     else if (adapter === "opencode" && parsed.visibleText.trim()) {

package/dist/bridge/bridge-process-reaper.js

@@ -303,10 +303,52 @@ async function waitForProcessExit(pid, timeoutMs) {
     }
     return !isPidAlive(pid);
 }
+/**
+ * Collect all descendant PIDs of `rootPid` on POSIX by walking `pgrep -P`.
+ * Used so killProcessTreeSync can reach grandchildren even when the child was
+ * spawned without `detached` (and therefore shares our process group).
+ */
+function collectPosixDescendantsSync(rootPid) {
+    const descendants = [];
+    const stack = [rootPid];
+    while (stack.length > 0) {
+        const parent = stack.pop();
+        if (parent === undefined) {
+            break;
+        }
+        try {
+            const result = spawnSync("pgrep", ["-P", String(parent)], {
+                encoding: "utf8",
+                windowsHide: true,
+            });
+            if (result.error || result.status !== 0) {
+                continue;
+            }
+            const stdout = result.stdout ?? "";
+            for (const line of stdout.split(/\r?\n/)) {
+                const childPid = Number.parseInt(line.trim(), 10);
+                if (Number.isInteger(childPid) &&
+                    childPid > 0 &&
+                    childPid !== rootPid &&
+                    !descendants.includes(childPid)) {
+                    descendants.push(childPid);
+                    stack.push(childPid);
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return descendants;
+}
 /**
  * Synchronously kill a process and its entire descendant tree.
  * On Windows uses `taskkill /T /F /PID` to recursively kill all descendants.
- * On other platforms uses `process.kill(pid)` directly.
+ * On POSIX, first tries the process group (kill -pgid) for group leaders, then
+ * walks the descendant tree via pgrep — required because codex/opencode children
+ * are spawned without `detached`, so they share our process group and a bare
+ * kill(pid) would orphan them on Linux/macOS.
  */
 export function killProcessTreeSync(pid) {
     if (!Number.isInteger(pid) || pid <= 0) {
@@ -327,15 +369,28 @@ export function killProcessTreeSync(pid) {
         }
     }
     else {
+        // Best effort: signal the whole group if the child happens to be a leader.
         try {
             process.kill(-pid);
         }
-        catch {
+        catch { /* not a group leader or already gone */ }
+        // Walk and kill descendants (leaves first), then the root, so grandchildren
+        // are not re-parented to init and left running.
+        const descendants = collectPosixDescendantsSync(pid);
+        for (let i = descendants.length - 1; i >= 0; i--) {
+            const descendantPid = descendants[i];
+            if (descendantPid === undefined) {
+                continue;
+            }
             try {
-                process.kill(pid);
+                process.kill(descendantPid);
             }
             catch { /* best effort */ }
         }
+        try {
+            process.kill(pid);
+        }
+        catch { /* best effort */ }
     }
 }
 export async function reapPeerBridgeProcesses(params = {}) {

package/dist/bridge/bridge-state.js

@@ -1,5 +1,5 @@
 import fs from "node:fs";
-import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, ensureWorkspaceChannelDir, ensureChannelDataDir, } from "../wechat/channel-config.js";
+import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, appendBoundedLog, ensureWorkspaceChannelDir, ensureChannelDataDir, } from "../wechat/channel-config.js";
 import { buildInstanceId } from "./bridge-utils.js";
 const ORPHAN_LOCK_RECLAIM_TIMEOUT_MS = 2_000;
 const ORPHAN_LOCK_RECLAIM_POLL_MS = 100;
@@ -280,7 +280,7 @@ export class BridgeStateStore {
     }
     appendLog(message) {
         ensureChannelDataDir();
-        fs.appendFileSync(BRIDGE_LOG_FILE, `[${new Date().toISOString()}] ${message}\n`, "utf-8");
+        appendBoundedLog(BRIDGE_LOG_FILE, `[${new Date().toISOString()}] ${message}\n`);
     }
     releaseLock() {
         try {
@@ -293,9 +293,17 @@ export class BridgeStateStore {
             // Best effort cleanup.
         }
     }
-    save() {
+    writeAtomicJsonFile(filePath, value) {
         ensureChannelDataDir();
-        fs.writeFileSync(this.stateFilePath, JSON.stringify(this.state, null, 2), "utf-8");
+        const data = JSON.stringify(value, null, 2);
+        // temp + rename so a crash mid-write cannot leave a truncated/half-written
+        // state or lock file that would break the next launch or look like a stale lock.
+        const tempPath = `${filePath}.${process.pid}.tmp`;
+        fs.writeFileSync(tempPath, data, "utf-8");
+        fs.renameSync(tempPath, filePath);
+    }
+    save() {
+        this.writeAtomicJsonFile(this.stateFilePath, this.state);
     }
     acquireLock() {
         const existing = readBridgeLockFile();
@@ -317,7 +325,7 @@ export class BridgeStateStore {
                 throw buildLockConflictError(existing);
             }
         }
-        fs.writeFileSync(BRIDGE_LOCK_FILE, JSON.stringify(this.lockPayload, null, 2), "utf-8");
+        this.writeAtomicJsonFile(BRIDGE_LOCK_FILE, this.lockPayload);
     }
     verifyRuntimeOwnership() {
         const workspaceState = this.readWorkspaceStateFile();
@@ -336,7 +344,7 @@ export class BridgeStateStore {
             this.save();
         }
         if (ownership.rehydratedLock) {
-            fs.writeFileSync(BRIDGE_LOCK_FILE, JSON.stringify(this.lockPayload, null, 2), "utf-8");
+            this.writeAtomicJsonFile(BRIDGE_LOCK_FILE, this.lockPayload);
         }
         return ownership;
     }

package/dist/bridge/bridge-utils.js

@@ -4,7 +4,11 @@ import path from "node:path";
 const ANSI_ESCAPE_RE = 
 // eslint-disable-next-line no-control-regex
 /\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
-export const MESSAGE_START_GRACE_MS = 5_000;
+// 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,
+// a PC clock running slightly ahead silently dropped fresh messages.
+export const MESSAGE_START_GRACE_MS = 30_000;
 const WECHAT_ATTACHMENT_SEND_INTENT_RE = /\b(send|upload|attach|forward|share)\b/i;
 const WECHAT_ATTACHMENT_SEND_INTENT_ZH_RE = /发送|发给我|发我|给我发|发过来|发一下|发来|发到|发微信|上传|转发|分享|传给我|传我|传到/;
 const WECHAT_ATTACHMENT_SHORT_SEND_ZH_RE = /^(?:发|发呀|发呢|发吧|直接发|发给我|发我|发微信|发送微信)$/;
@@ -948,13 +952,21 @@ function extractInlineWechatAttachments(text) {
         attachments,
     };
 }
+// Platform-independent absolute-path check for WeChat attachment candidates.
+// Recognizes Windows drive paths (C:\, C:/) and POSIX root paths (/, \), so an
+// agent-emitted path resolves on any host OS. Node's path.isAbsolute is
+// platform-specific: it rejects "C:\Users\..." on Linux/macOS, which dropped
+// the attachment and failed CI on non-Windows runners.
+function isWechatAttachmentAbsolutePath(candidate) {
+    return /^(?:[A-Za-z]:[\\/]|[\\/])/.test(candidate);
+}
 function resolveWechatAttachmentPath(candidatePath) {
     const normalizedCandidate = normalizeWechatAttachmentCandidate(candidatePath);
     if (!normalizedCandidate) {
         return null;
     }
-    if (path.isAbsolute(normalizedCandidate)) {
-        return path.normalize(normalizedCandidate);
+    if (isWechatAttachmentAbsolutePath(normalizedCandidate)) {
+        return normalizedCandidate;
     }
     const homeRelativeMatch = /^(?:~[\\/])?(Desktop|Documents|Downloads|Pictures|Videos|Music)([\\/].+)?$/i.exec(normalizedCandidate);
     if (!homeRelativeMatch) {
@@ -967,12 +979,15 @@ function resolveWechatAttachmentPath(candidatePath) {
     }
     return path.normalize(path.join(os.homedir(), ...relativeSegments));
 }
+// Trim and clean a WeChat attachment candidate path. Intentionally does NOT
+// rewrite separators to path.sep: the path must keep its original separator
+// style (Windows "\" or POSIX "/") so the bridge can resolve agent-emitted
+// paths regardless of host OS (see isWechatAttachmentAbsolutePath).
 function normalizeWechatAttachmentCandidate(candidatePath) {
     return candidatePath
         .trim()
         .replace(/^`|`$/g, "")
-        .replace(/\.\s+([A-Za-z0-9]{2,8})(?=$|[?/\s])/g, ".$1")
-        .replace(/[\\/]+/g, path.sep);
+        .replace(/\.\s+([A-Za-z0-9]{2,8})(?=$|[?/\s])/g, ".$1");
 }
 function inferInlineWechatAttachmentKind(filePath) {
     const extension = path.extname(filePath).toLowerCase();
@@ -1305,9 +1320,49 @@ export class OutputBatcher {
             .catch(() => undefined);
     }
 }
+// When CLI_BRIDGE_STRICT_APPROVAL is enabled, no permission request is
+// auto-approved: everything is forwarded to WeChat for an explicit
+// /confirm or /deny decision.
+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) {
-    if (!Number.isFinite(createdAtMs)) {
-        return true;
+    // A missing or unparsable timestamp must not drop the message: treat it as
+    // fresh and let normal processing continue.
+    if (!Number.isFinite(createdAtMs) || createdAtMs <= 0) {
+        return false;
     }
     return createdAtMs < bridgeStartedAtMs - graceMs;
 }

package/dist/bridge/claude-hook.js

@@ -30,6 +30,7 @@ async function main() {
         const socket = net.connect({ host: "127.0.0.1", port });
         let buffer = "";
         const finish = () => {
+            clearTimeout(connectTimer);
             try {
                 socket.destroy();
             }
@@ -38,7 +39,13 @@ async function main() {
             }
             resolve();
         };
+        // Bail out if the bridge hook server never accepts the connection, so a
+        // wedged bridge cannot leave Claude CLI blocked on this hook forever.
+        // Once connected, we wait indefinitely: approval responses legitimately
+        // take as long as the user needs to reply on WeChat.
+        const connectTimer = setTimeout(finish, 10_000);
         socket.once("connect", () => {
+            clearTimeout(connectTimer);
             try {
                 socket.write(`${JSON.stringify({ token, requestId, payload })}\n`);
             }