@unlinearity/cli-wechat-bridge 1.1.1 → 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)，同时把本地输出、审批请求与运行状态同步回微信。

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) {

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`);
             }

package/dist/bridge/claude-hooks.js

@@ -1,4 +1,4 @@
-import { WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE, containsWechatOutboundAttachmentPath, isHighRiskShellCommand, isWechatOutboundAttachmentWriteCommand, normalizeOutput, truncatePreview, } from "./bridge-utils.js";
+import { WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE, containsWechatOutboundAttachmentPath, isHighRiskShellCommand, isStrictApprovalModeEnabled, isWechatOutboundAttachmentWriteCommand, normalizeOutput, truncatePreview, } from "./bridge-utils.js";
 export const CLAUDE_WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE = WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE;
 const FILE_MUTATION_TOOL_NAMES = new Set([
     "Write",
@@ -88,6 +88,11 @@ export function buildClaudeHookScript(params) {
         return [
             "@echo off",
             "setlocal",
+            // The script is written as UTF-8, but cmd.exe decodes batch lines with
+            // the active OEM code page (GBK on zh-CN systems). Paths below may
+            // contain non-ASCII characters (e.g. a Chinese Windows user name), so
+            // switch to UTF-8 before any line that embeds a path.
+            "chcp 65001>nul",
             `set "CLAUDE_WECHAT_HOOK_PORT=${params.hookPort}"`,
             `set "CLAUDE_WECHAT_HOOK_TOKEN=${params.hookToken}"`,
             `${command} ${stderrRedirect}`,
@@ -205,7 +210,10 @@ export function getClaudeWechatOutboundAttachmentDenyMessage(payload) {
     }
     return null;
 }
-export function getClaudePermissionAutoResponse(payload) {
+export function getClaudePermissionAutoResponse(payload, env = process.env) {
+    if (isStrictApprovalModeEnabled(env)) {
+        return null;
+    }
     const toolName = typeof payload.tool_name === "string" ? payload.tool_name.trim() : "";
     if (!toolName) {
         return null;

package/dist/bridge/wechat-bridge.js

@@ -266,7 +266,9 @@ async function main() {
     }
     const transport = new WeChatTransport({ log, logError });
     // 非阻塞地检查更新（不影响启动速度，也避免首次登录时打断二维码输出）
-    setTimeout(async () => {
+    // unref：不能让这个延迟检查把 event loop 挂活（如 --doctor 或快速退出场景），
+    // 否则会与强制退出 teardown 竞态。
+    const updateCheckTimer = setTimeout(async () => {
         try {
             const versionInfo = await checkForUpdate();
             if (versionInfo?.hasUpdate) {
@@ -277,6 +279,7 @@ async function main() {
             // 静默失败，不影响正常使用
         }
     }, 3000); // 延迟3秒，确保不影响启动
+    updateCheckTimer.unref?.();
     const stateStore = new BridgeStateStore({
         ...options,
         authorizedUserId: credentials.userId,
@@ -338,6 +341,7 @@ async function main() {
     let lastOutputAt = 0;
     let lastHeartbeatAt = 0;
     let consecutivePollFailures = 0;
+    let backlogNoticeSent = false;
     const queueWechatTextAction = (action) => {
         const run = textSendChain.then(action);
         textSendChain = run.then(() => undefined, () => undefined);
@@ -661,6 +665,13 @@ async function main() {
             if (pollResult.ignoredBacklogCount > 0) {
                 stateStore.incrementIgnoredBacklog(pollResult.ignoredBacklogCount);
                 stateStore.appendLog(`ignored_startup_backlog: count=${pollResult.ignoredBacklogCount}`);
+                if (!backlogNoticeSent) {
+                    backlogNoticeSent = true;
+                    await queueWechatMessage(stateStore.getState().authorizedUserId, t("bridge.backlogIgnored", {
+                        count: pollResult.ignoredBacklogCount,
+                        graceSeconds: Math.round(MESSAGE_START_GRACE_MS / 1000),
+                    }), "notice");
+                }
             }
             for (const message of pollResult.messages) {
                 if (!ensureRuntimeOwnership()) {

package/dist/commands/check-update.js

@@ -7,12 +7,23 @@ async function main() {
     console.log(`Checking for updates...`);
     const versionInfo = await checkForUpdate(true); // 强制检查
     if (!versionInfo) {
-        console.log(`ERROR: Unable to check for updates, please check your network connection`);
-        process.exit(1);
+        console.error(`ERROR: Unable to check for updates.`);
+        console.error(`Could not read the latest version from the npm registry or GitHub.`);
+        console.error(`Possible causes:`);
+        console.error(`  - No network connection`);
+        console.error(`  - A proxy is required but not configured (set HTTP_PROXY/HTTPS_PROXY and NODE_USE_ENV_PROXY=1)`);
+        console.error(`  - The npm registry or GitHub API are temporarily unavailable`);
+        console.error(`\nCheck the latest release manually:`);
+        console.error(`  https://github.com/UNLINEARITY/CLI-WeChat-Bridge/releases`);
+        // 不使用 process.exit():强制退出会打断 fetch 底层 handle 的关闭流程,
+        // 在 Windows + Node 24 上触发 libuv 的 UV_HANDLE_CLOSING 断言崩溃。
+        // 设置 exitCode 后让事件循环自然退出。
+        process.exitCode = 1;
+        return;
     }
     if (!versionInfo.hasUpdate) {
         console.log(`OK: Already up to date (v${versionInfo.latest})`);
-        process.exit(0);
+        return;
     }
     console.log(`[New Version Available] v${versionInfo.latest}`);
     console.log(`Current version: v${versionInfo.current}\n`);
@@ -26,5 +37,5 @@ async function main() {
 }
 main().catch((error) => {
     console.error(`Error checking for updates: ${error.message}`);
-    process.exit(1);
+    process.exitCode = 1;
 });

package/dist/companion/local-companion-start.js

@@ -283,6 +283,11 @@ function startBridgeInBackground(options) {
         stdio: "ignore",
         windowsHide: true,
     });
+    // A detached background spawn must still handle its own 'error' event
+    // (e.g. ENOENT), otherwise it surfaces as an unhandled exception.
+    child.on("error", () => {
+        /* best effort: background bridge failed to detach */
+    });
     child.unref();
 }
 async function waitForEndpoint(cwd, adapter, timeoutMs) {

package/dist/daemon/wechat-daemon.js

@@ -13,7 +13,7 @@ import { readBridgeLockFile, } from "../bridge/bridge-state.js";
 import { getProcessRecordByPid, isWechatDaemonCommandLine, killProcessTreeSync, listWechatDaemonProcesses, reapOrphanedOpencodeProcesses, reapPeerBridgeProcesses, } from "../bridge/bridge-process-reaper.js";
 import { buildOneTimeCode, buildWechatInboundPrompt, formatApprovalMessage, formatDuration, formatMirroredUserInputMessage, formatPendingApprovalReminder, formatPendingUserInputReminder, formatSessionSwitchMessage, formatTaskFailedMessage, formatUserInputRequestMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parsePendingUserInputAnswerCommand, parseWechatControlCommand, truncatePreview, } from "../bridge/bridge-utils.js";
 import { formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, } from "../bridge/wechat-bridge.js";
-import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, ensureChannelDataDir, migrateLegacyChannelFiles, } from "../wechat/channel-config.js";
+import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, appendBoundedLog, ensureChannelDataDir, migrateLegacyChannelFiles, } from "../wechat/channel-config.js";
 import { ensureWechatCredentials } from "../wechat/setup.js";
 import { formatBindCommandUsage, formatBindingsListMessage, isBindCommandPrefix, listBindings, loadEmojiBindings, parseEmojiBindingsCommand, removeBinding, resolveEmojiCommand, setBinding, } from "./emoji-bindings.js";
 import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, describeWechatTransportError, isWechatContextTokenStaleError, WeChatTransport, } from "../wechat/wechat-transport.js";
@@ -45,7 +45,7 @@ function logError(message) {
 }
 function appendDaemonLog(message) {
     ensureChannelDataDir();
-    fs.appendFileSync(BRIDGE_LOG_FILE, `[${new Date().toISOString()}] daemon: ${message}\n`, "utf8");
+    appendBoundedLog(BRIDGE_LOG_FILE, `[${new Date().toISOString()}] daemon: ${message}\n`);
 }
 function computePollRetryDelayMs(consecutiveFailures) {
     const normalizedFailures = Math.max(1, consecutiveFailures);
@@ -444,6 +444,7 @@ class WechatDaemon {
     slots = new Map();
     startedAt = new Date().toISOString();
     bridgeStartedAtMs = Date.now();
+    backlogNoticeSent = false;
     activeAdapter = null;
     takenOverAdapter;
     textSendChain = Promise.resolve();
@@ -582,6 +583,13 @@ class WechatDaemon {
             }
             if (pollResult.ignoredBacklogCount > 0) {
                 appendDaemonLog(`ignored_startup_backlog: count=${pollResult.ignoredBacklogCount}`);
+                if (!this.backlogNoticeSent) {
+                    this.backlogNoticeSent = true;
+                    await this.queueWechatMessage(this.authorizedUserId, t("bridge.backlogIgnored", {
+                        count: pollResult.ignoredBacklogCount,
+                        graceSeconds: Math.round(MESSAGE_START_GRACE_MS / 1000),
+                    }), "notice");
+                }
             }
             for (const message of pollResult.messages) {
                 try {

package/dist/i18n/messages-en.js

@@ -9,6 +9,7 @@ export const messages = {
     "bridge.status.busy": "{adapter} is still working on the previous request. Wait for it to finish or send /interrupt.",
     "bridge.newSession.done": "New session started.",
     "bridge.fatalError": "Bridge error: {message}",
+    "bridge.backlogIgnored": "Ignored {count} backlog message(s) sent before the bridge started (they will not be processed).\nIf you actually sent them after the bridge started, your system clock is likely skewed by more than {graceSeconds}s — sync the clock and restart the bridge.",
     // === Daemon welcome & control ===
     "daemon.welcome": "WeChat Daemon ready.\nCWD: {cwd}\nActive: {adapter}\n\nCommands: /claude, /codex, /opencode, /stop, /confirm, /deny, /status\n{bindings}\n\nManage: /bind [emoji] cmd, /unbind [emoji], /bindings",
     "daemon.noActiveAdapter": "No active terminal is selected. Send /codex, /claude, or /opencode to start one.",
@@ -55,6 +56,15 @@ export const messages = {
     "doctor.label.node": "Node.js",
     "doctor.label.platform": "Platform",
     "doctor.label.winBuild": "Windows build",
+    "doctor.label.codePage": "Console code page",
+    "doctor.codePage.nonAsciiWarning": "{codePage} (not UTF-8 and the data directory path contains non-ASCII characters; hook scripts from older versions break in this environment — upgrade to the latest release)",
+    "doctor.label.connectivity": "WeChat connectivity",
+    "doctor.connectivity.ok": "reachable ({baseUrl})",
+    "doctor.connectivity.unreachable": "cannot reach {baseUrl} (check network and firewall)",
+    "doctor.connectivity.proxyHint": "cannot reach {baseUrl}. Proxy {proxy} detected, but Node fetch ignores proxy environment variables by default; if your network requires the proxy, set NODE_USE_ENV_PROXY=1 and retry.",
+    "doctor.label.clock": "System clock",
+    "doctor.clock.ok": "~{skewSeconds}s skew vs server time",
+    "doctor.clock.skewWarning": "~{skewSeconds}s skew vs server time (large skew makes the bridge treat fresh messages as pre-start backlog — sync the system clock)",
     "doctor.label.nodePty": "node-pty",
     "doctor.label.shell": "shell",
     "doctor.label.dataDir": "Data dir",

package/dist/i18n/messages-zh.js

@@ -9,6 +9,7 @@ export const messages = {
     "bridge.status.busy": "{adapter} 仍在处理上一个请求。请等待完成或发送 /interrupt。",
     "bridge.newSession.done": "已开始新会话。",
     "bridge.fatalError": "桥接错误: {message}",
+    "bridge.backlogIgnored": "已忽略 {count} 条桥接启动前的积压消息（不会自动处理）。\n如果你是在桥接启动后才发送的消息却看到此提示，说明本机系统时钟可能不准（偏差超过 {graceSeconds} 秒），请校准时间后重启桥接。",
     // === Daemon 欢迎 & 控制 ===
     "daemon.welcome": "微信 Daemon 就绪。\n工作目录: {cwd}\n当前: {adapter}\n\n命令: /claude, /codex, /opencode, /stop, /confirm, /deny, /status\n{bindings}\n\n管理: /bind [表情] 命令, /unbind [表情], /bindings",
     "daemon.noActiveAdapter": "未选择活跃终端。发送 /codex、/claude 或 /opencode 启动一个。",
@@ -55,6 +56,15 @@ export const messages = {
     "doctor.label.node": "Node.js",
     "doctor.label.platform": "平台",
     "doctor.label.winBuild": "Windows build",
+    "doctor.label.codePage": "控制台代码页",
+    "doctor.codePage.nonAsciiWarning": "{codePage}（非 UTF-8，且数据目录路径含非 ASCII 字符；旧版本的 hook 脚本在此环境下会乱码失效，请升级到最新版本）",
+    "doctor.label.connectivity": "微信服务可达性",
+    "doctor.connectivity.ok": "可达 ({baseUrl})",
+    "doctor.connectivity.unreachable": "无法访问 {baseUrl}（检查网络与防火墙）",
+    "doctor.connectivity.proxyHint": "无法访问 {baseUrl}。检测到代理 {proxy}，但 Node fetch 默认不使用代理环境变量；若必须经代理出网，请设置 NODE_USE_ENV_PROXY=1 后重试。",
+    "doctor.label.clock": "系统时钟",
+    "doctor.clock.ok": "与服务器时间偏差约 {skewSeconds}s",
+    "doctor.clock.skewWarning": "与服务器时间偏差约 {skewSeconds}s（偏差过大会导致桥接启动后的消息被当作积压忽略，请校准系统时间）",
     "doctor.label.nodePty": "node-pty",
     "doctor.label.shell": "shell",
     "doctor.label.dataDir": "数据目录",

package/dist/utils/doctor.js

@@ -7,12 +7,14 @@ import { normalizeBridgeLockPayload, shouldAutoReclaimBridgeLock, } from "../bri
 import { readLocalCompanionEndpoint as readWorkspaceEndpoint, } from "../companion/local-companion-link.js";
 import { isDaemonEndpointAlive, } from "../daemon/daemon-link.js";
 import { t } from "../i18n/index.js";
-import { resolveChannelDataDir } from "../wechat/channel-config.js";
+import { DEFAULT_BASE_URL, resolveChannelDataDir } from "../wechat/channel-config.js";
 const STATE_OK = "[ok]";
 const STATE_WARN = "[warn]";
 const STATE_FAIL = "[fail]";
 const RUNTIME_ENDPOINT_TIMEOUT_MS = 500;
 const DAEMON_ENDPOINT_TIMEOUT_MS = 500;
+const SERVER_DATE_TIMEOUT_MS = 3_000;
+const CLOCK_SKEW_WARN_MS = 30_000;
 function msg(key, params) {
     return t(`doctor.${key}`, params);
 }
@@ -58,6 +60,53 @@ function getPlatformPtyFix(platform) {
             return "npm rebuild node-pty";
     }
 }
+function defaultGetWindowsCodePage() {
+    try {
+        const output = execFileSync("cmd.exe", ["/d", "/c", "chcp"], {
+            stdio: ["ignore", "pipe", "ignore"],
+            encoding: "utf8",
+            windowsHide: true,
+        });
+        const match = /(\d+)\s*\.?\s*$/.exec(output.trim());
+        return match ? Number(match[1]) : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function defaultFetchServerDate() {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), SERVER_DATE_TIMEOUT_MS);
+    try {
+        const res = await fetch(DEFAULT_BASE_URL, {
+            method: "GET",
+            signal: controller.signal,
+        });
+        const dateHeader = res.headers.get("date");
+        if (!dateHeader) {
+            return null;
+        }
+        const parsed = new Date(dateHeader);
+        return Number.isFinite(parsed.getTime()) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function containsNonAscii(value) {
+    return Array.from(value).some((character) => character.charCodeAt(0) > 0x7f);
+}
+function pickProxyEnvValue(env) {
+    return (env.HTTPS_PROXY ??
+        env.https_proxy ??
+        env.HTTP_PROXY ??
+        env.http_proxy ??
+        env.ALL_PROXY ??
+        env.all_proxy)?.trim() || undefined;
+}
 function defaultIsProcessAlive(pid) {
     if (!Number.isInteger(pid) || pid <= 0) {
         return false;
@@ -100,6 +149,10 @@ function resolveDeps(deps = {}) {
         arch: deps.arch ?? process.arch,
         nodeVersion: deps.nodeVersion ?? process.version,
         osRelease: deps.osRelease ?? os.release,
+        env: deps.env ?? process.env,
+        now: deps.now ?? Date.now,
+        getWindowsCodePage: deps.getWindowsCodePage ?? defaultGetWindowsCodePage,
+        fetchServerDate: deps.fetchServerDate ?? defaultFetchServerDate,
         findExecutable: deps.findExecutable ?? findExecutable,
         loadNodePty: deps.loadNodePty ??
             (async () => {
@@ -503,6 +556,32 @@ export async function buildDoctorReport(options = {}, rawDeps = {}) {
         const build = parseInt(release.split(".").pop() ?? "0", 10);
         const ok = build >= 18309;
         lines.push(row(ok ? STATE_OK : STATE_FAIL, msg("label.winBuild"), ok ? String(build) : `${build} ${msg("winBuildConpty")}`));
+        const codePage = deps.getWindowsCodePage();
+        if (codePage !== null) {
+            const dataDirHasNonAscii = containsNonAscii(deps.resolveDataDir());
+            const risky = codePage !== 65001 && dataDirHasNonAscii;
+            lines.push(row(risky ? STATE_WARN : STATE_OK, msg("label.codePage"), risky
+                ? msg("codePage.nonAsciiWarning", { codePage })
+                : String(codePage)));
+        }
+    }
+    const proxyUrl = pickProxyEnvValue(deps.env);
+    const serverDate = await deps.fetchServerDate();
+    if (serverDate) {
+        lines.push(row(STATE_OK, msg("label.connectivity"), msg("connectivity.ok", {
+            baseUrl: DEFAULT_BASE_URL,
+        })));
+        const skewMs = deps.now() - serverDate.getTime();
+        const skewSeconds = Math.round(Math.abs(skewMs) / 1000);
+        const clockOk = Math.abs(skewMs) <= CLOCK_SKEW_WARN_MS;
+        lines.push(row(clockOk ? STATE_OK : STATE_WARN, msg("label.clock"), clockOk
+            ? msg("clock.ok", { skewSeconds })
+            : msg("clock.skewWarning", { skewSeconds })));
+    }
+    else {
+        lines.push(row(STATE_WARN, msg("label.connectivity"), proxyUrl && deps.env.NODE_USE_ENV_PROXY !== "1"
+            ? msg("connectivity.proxyHint", { baseUrl: DEFAULT_BASE_URL, proxy: proxyUrl })
+            : msg("connectivity.unreachable", { baseUrl: DEFAULT_BASE_URL })));
     }
     try {
         await deps.loadNodePty();

package/dist/utils/version-checker.js

@@ -1,48 +1,70 @@
 import fs from "node:fs";
 import path from "node:path";
-import { execSync } from "node:child_process";
 import { CHANNEL_DATA_DIR, ensureChannelDataDir } from "../wechat/channel-config.js";
 const UPDATE_CHECK_FILE = path.join(CHANNEL_DATA_DIR, "update-check.json");
 const CACHE_DURATION_MS = 24 * 60 * 60 * 1000; // 24小时
-/**
- * 使用 git 命令获取远程仓库最新版本号
- */
-export async function fetchLatestVersion() {
+// npm registry 是权威更新源——它是用户实际安装的渠道;GitHub tags 作为回退,
+// 以便在 registry 暂时不可达或包尚未发布时仍能给出最新版本。
+const NPM_PACKAGE_NAME = "cli-wechat-bridge";
+const DEFAULT_NPM_REGISTRY_URL = `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`;
+const DEFAULT_GITHUB_TAGS_URL = "https://api.github.com/repos/UNLINEARITY/CLI-WeChat-Bridge/tags?per_page=20";
+const FETCH_TIMEOUT_MS = 10_000;
+function resolveFetchDeps(options) {
+    return {
+        fetch: options.fetchImpl ?? globalThis.fetch,
+        npmRegistryUrl: options.npmRegistryUrl ?? DEFAULT_NPM_REGISTRY_URL,
+        githubTagsUrl: options.githubTagsUrl ?? DEFAULT_GITHUB_TAGS_URL,
+        timeoutMs: options.timeoutMs ?? FETCH_TIMEOUT_MS,
+    };
+}
+async function fetchJsonWithTimeout(url, deps) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), deps.timeoutMs);
     try {
-        // 尝试使用 git ls-remote 获取所有 tags
-        const tagsOutput = execSync('git ls-remote --tags origin', {
-            cwd: path.resolve(import.meta.dirname, "..", ".."),
-            encoding: 'utf-8',
-            stdio: ['ignore', 'pipe', 'ignore']
+        const res = await deps.fetch(url, {
+            method: "GET",
+            signal: controller.signal,
+            headers: { Accept: "application/json" },
         });
-        if (!tagsOutput) {
-            return null;
-        }
-        // 解析 tags，找到版本号格式（如 0.1.0, 0.2.0 等）
-        const versionTags = tagsOutput
-            .split('\n')
-            .filter(line => {
-            // 匹配 refs/tags/0.5.0 格式（不是 v0.5.0）
-            return line.includes('refs/tags/') &&
-                !line.includes('^{}') &&
-                /^\w+\s+refs\/tags\/\d+\.\d+\.\d+$/.test(line);
-        })
-            .map(line => {
-            const match = line.match(/refs\/tags\/(\d+\.\d+\.\d+)$/);
-            return match ? match[1] : null;
-        })
-            .filter((v) => v !== null);
-        if (versionTags.length === 0) {
+        if (!res.ok) {
             return null;
         }
-        // 按版本号排序，返回最新的
-        versionTags.sort((a, b) => compareVersions(b, a));
-        return versionTags[0] ?? null;
+        return await res.json();
     }
-    catch (error) {
-        // 如果 git 命令失败，静默返回 null
+    catch {
+        // 网络/超时/解析失败一律视为该源不可用,交由调用方回退。
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function fetchVersionFromNpm(deps) {
+    const data = await fetchJsonWithTimeout(deps.npmRegistryUrl, deps);
+    if (!data || typeof data !== "object") {
         return null;
     }
+    const version = data.version;
+    return typeof version === "string" ? parseVersion(version) : null;
+}
+async function fetchVersionFromGithub(deps) {
+    const data = await fetchJsonWithTimeout(deps.githubTagsUrl, deps);
+    if (!Array.isArray(data)) {
+        return null;
+    }
+    const versions = data
+        .map((tag) => parseVersion(tag.name))
+        .filter((v) => v !== null)
+        .sort((a, b) => compareVersions(b, a));
+    return versions[0] ?? null;
+}
+/**
+ * 从 npm registry 获取最新版本号(回退到 GitHub tags)。
+ * 通过 HTTPS 请求而非本地 git 命令,因此对全局安装的命令(wechat-check-update)同样可用。
+ */
+export async function fetchLatestVersion(options = {}) {
+    const deps = resolveFetchDeps(options);
+    return (await fetchVersionFromNpm(deps)) ?? (await fetchVersionFromGithub(deps));
 }
 /**
  * 从本地 package.json 读取当前版本
@@ -85,6 +107,17 @@ function writeUpdateCache(cache) {
         // 静默失败，不影响正常使用
     }
 }
+const VERSION_PATTERN = /(\d+\.\d+\.\d+)/;
+/**
+ * 从任意字符串中提取版本号,兼容带 "v" 前缀的 tag(如 "v1.1.1")。
+ */
+export function parseVersion(raw) {
+    if (typeof raw !== "string") {
+        return null;
+    }
+    const match = VERSION_PATTERN.exec(raw.trim());
+    return match ? (match[1] ?? null) : null;
+}
 /**
  * 比较两个版本号
  * @returns 返回值 > 0 表示 version1 更新，< 0 表示 version2 更新，= 0 表示相等
@@ -146,16 +179,16 @@ export async function checkForUpdate(forceCheck = false) {
  */
 export function formatUpdateMessage(versionInfo) {
     const { current, latest } = versionInfo;
-    return `
-[Update Available] Version ${latest} is available (current: ${current})
-
-Update instructions:
-   cd CLI-WeChat-Bridge
-   git pull
-   bun install
-   npm install -g .
-
-For more information:
-   https://github.com/UNLINEARITY/CLI-WeChat-Bridge/releases
+    return `
+[Update Available] Version ${latest} is available (current: ${current})
+
+Update instructions:
+   cd CLI-WeChat-Bridge
+   git pull
+   bun install
+   npm install -g .
+
+For more information:
+   https://github.com/UNLINEARITY/CLI-WeChat-Bridge/releases
 `;
 }

package/dist/wechat/channel-config.js

@@ -18,6 +18,34 @@ export const SYNC_BUF_FILE = path.join(CHANNEL_DATA_DIR, "sync_buf.txt");
 export const CONTEXT_CACHE_FILE = path.join(CHANNEL_DATA_DIR, "context_tokens.json");
 export const BRIDGE_STATE_FILE = path.join(CHANNEL_DATA_DIR, "bridge-state.json");
 export const BRIDGE_LOG_FILE = path.join(CHANNEL_DATA_DIR, "bridge.log");
+// Hard cap for bridge.log. Long-running daemons otherwise grow it without bound.
+export const BRIDGE_LOG_MAX_BYTES = 5 * 1024 * 1024; // 5 MiB
+/**
+ * Append a line to a log file, trimming it down to the tail half whenever it
+ * exceeds BRIDGE_LOG_MAX_BYTES. Trimming is best-effort under concurrent
+ * writers (a few lines may be lost during a trim) but keeps the file bounded.
+ */
+export function appendBoundedLog(filePath, line) {
+    try {
+        const stat = fs.statSync(filePath);
+        if (stat.size > BRIDGE_LOG_MAX_BYTES) {
+            const keepSize = Math.floor(BRIDGE_LOG_MAX_BYTES / 2);
+            const fd = fs.openSync(filePath, "r");
+            try {
+                const tail = Buffer.alloc(keepSize);
+                const bytesRead = fs.readSync(fd, tail, 0, keepSize, stat.size - keepSize);
+                fs.writeFileSync(filePath, tail.subarray(0, bytesRead));
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        }
+    }
+    catch {
+        // File missing or unreadable: fall through to a plain append.
+    }
+    fs.appendFileSync(filePath, line);
+}
 export const BRIDGE_LOCK_FILE = path.join(CHANNEL_DATA_DIR, "bridge.lock.json");
 export const DAEMON_ENDPOINT_FILE = path.join(CHANNEL_DATA_DIR, "daemon-endpoint.json");
 export const CODEX_PANEL_ENDPOINT_FILE = path.join(CHANNEL_DATA_DIR, "codex-panel-endpoint.json");

package/dist/wechat/wechat-transport.js

@@ -306,7 +306,12 @@ export function classifyWechatTransportError(error) {
 }
 function writeJsonFile(filePath, value) {
     ensureChannelDataDir();
-    fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
+    const data = JSON.stringify(value, null, 2);
+    // Atomic write via temp file + rename, so a crash mid-write cannot leave a
+    // truncated/half-written JSON that would break readers on the next launch.
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    fs.writeFileSync(tempPath, data, "utf-8");
+    fs.renameSync(tempPath, filePath);
 }
 function randomWechatUin() {
     const uint32 = crypto.randomBytes(4).readUInt32BE(0);
@@ -445,7 +450,15 @@ async function getUploadUrl(account, params) {
         token: account.token,
         timeoutMs: SEND_TIMEOUT_MS,
     });
-    return JSON.parse(raw);
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        // A 200-OK but non-JSON body (e.g. an HTML error page, empty body) would
+        // otherwise throw an unclassified SyntaxError that bypasses transport error
+        // classification/retry. Surface it as a meaningful error instead.
+        throw new Error(`getUploadUrl returned a non-JSON response (${raw.length} bytes): ${String(error)}`, { cause: error });
+    }
 }
 function buildCdnUploadUrl(cdnBaseUrl, uploadParam, filekey) {
     return `${cdnBaseUrl}/upload?encrypted_query_param=${encodeURIComponent(uploadParam)}&filekey=${encodeURIComponent(filekey)}`;
@@ -678,11 +691,25 @@ export function buildInboundMessageClaimPath(messageKey, claimsDir = INBOUND_MES
     return path.join(claimsDir, fileName);
 }
 export function clearInboundMessageClaims(claimsDir = INBOUND_MESSAGE_CLAIMS_DIR) {
+    // Delete claim files individually from a directory snapshot rather than
+    // `rmSync(claimsDir, { recursive })`. A recursive rmdir can remove a file a
+    // concurrent process just created via tryClaimInboundMessage, silently
+    // invalidating its claim and letting the same message be double-processed.
+    // Per-file removal only deletes files present at snapshot time.
+    let entries;
     try {
-        fs.rmSync(claimsDir, { recursive: true, force: true });
+        entries = fs.readdirSync(claimsDir);
     }
     catch {
-        // Best effort cleanup.
+        return; // directory does not exist; nothing to clear
+    }
+    for (const entry of entries) {
+        try {
+            fs.rmSync(path.join(claimsDir, entry), { force: true });
+        }
+        catch {
+            // best effort
+        }
     }
 }
 export function tryClaimInboundMessage(messageKey, options = {}) {
@@ -719,7 +746,11 @@ export function tryClaimInboundMessage(messageKey, options = {}) {
             ? error.code
             : "";
         if (code !== "EEXIST") {
-            return true;
+            // Real persistence failure (permissions, disk full, missing dir, ...).
+            // Returning true here would claim success WITHOUT writing the claim file,
+            // letting concurrent processes all think they own this message and
+            // double-process it. Fail closed so the message is retried instead.
+            return false;
         }
     }
     try {
@@ -849,23 +880,28 @@ export class WeChatTransport {
             if (!extracted.text && extracted.attachments.length === 0) {
                 continue;
             }
-            const messageKey = buildMessageKey(rawMessage);
-            if (!this.rememberMessage(messageKey)) {
-                continue;
-            }
-            if (!tryClaimInboundMessage(buildScopedMessageClaimKey(account.accountId, messageKey))) {
-                continue;
-            }
             const senderId = rawMessage.from_user_id ?? "unknown";
             if (rawMessage.context_token) {
                 this.cacheContextToken(senderId, rawMessage.context_token);
             }
+            // Filter pre-start backlog BEFORE claiming/remembering the message so a
+            // skipped message is not permanently locked away from other processes.
+            // A missing create_time_ms is treated as fresh rather than dropped.
             const createdAtMs = rawMessage.create_time_ms ?? 0;
             if (typeof options.minCreatedAtMs === "number" &&
-                (!Number.isFinite(createdAtMs) || createdAtMs < options.minCreatedAtMs)) {
+                Number.isFinite(createdAtMs) &&
+                createdAtMs > 0 &&
+                createdAtMs < options.minCreatedAtMs) {
                 ignoredBacklogCount += 1;
                 continue;
             }
+            const messageKey = buildMessageKey(rawMessage);
+            if (!this.rememberMessage(messageKey)) {
+                continue;
+            }
+            if (!tryClaimInboundMessage(buildScopedMessageClaimKey(account.accountId, messageKey))) {
+                continue;
+            }
             const { attachments, failureLines } = await this.downloadInboundAttachments(extracted.attachments, rawMessage);
             const text = appendInboundAttachmentFailureText(extracted.text, failureLines);
             messages.push({

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@unlinearity/cli-wechat-bridge",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "CLI WeChat Bridge for Codex, Claude Code, OpenCode, and PowerShell over WeChat",
   "type": "module",
   "files": [
     "bin/",
     "dist/",
+    "scripts/ensure-node-pty-permissions.mjs",
     "README.md",
     "LICENSE.txt"
   ],