@unlinearity/cli-wechat-bridge 1.1.2 → 1.1.4

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

@@ -32,21 +32,25 @@ export const LOCAL_COMPANION_RECONNECT_GRACE_MS = 15_000;
 export const CLAUDE_HOOK_LISTEN_HOST = "127.0.0.1";
 export const CLAUDE_HELP_PROBE_TIMEOUT_MS = 5_000;
 export const CLAUDE_WECHAT_WORKING_NOTICE_DELAY_MS = 12_000;
-export const DEFAULT_UNIX_SHELL_CANDIDATES = ["pwsh", "bash", "zsh", "sh"];
-export const POSIX_SHELL_NAMES = new Set(["bash", "zsh", "sh", "dash", "ksh"]);
 export const CLAUDE_FLAG_SUPPORT_CACHE = new Map();
 export const OPENCODE_SERVER_HOST = "127.0.0.1";
 export const OPENCODE_SERVER_READY_TIMEOUT_MS = 10_000;
 export const OPENCODE_SSE_RECONNECT_DELAY_MS = 2_000;
 export const OPENCODE_SESSION_IDLE_SETTLE_MS = 1_500;
 export const OPENCODE_WECHAT_WORKING_NOTICE_DELAY_MS = 12_000;
+// `opencode serve` binds its TCP port before the HTTP layer is ready. The
+// health probe therefore retries within this total budget so the startup
+// race self-heals instead of hanging until undici's ~300s headersTimeout.
+export const OPENCODE_HTTP_READY_TIMEOUT_MS = 15_000;
+export const OPENCODE_HTTP_READY_PROBE_TIMEOUT_MS = 3_000;
+export const OPENCODE_HTTP_READY_PROBE_INTERVAL_MS = 500;
 export function buildCodexCliArgs(remoteUrl, options = {}) {
     assertNoReservedExtraCliArgs(options.extraCliArgs ?? [], ["--remote", "--remote-auth-token-env"], "Codex remote connection");
     const args = [];
     if (options.resumeThreadId) {
         args.push("resume", options.resumeThreadId);
     }
-    args.push("--enable", "tui_app_server", "--remote", remoteUrl);
+    args.push("--remote", remoteUrl);
     if (options.inlineMode) {
         args.push("--no-alt-screen");
     }
@@ -672,44 +676,25 @@ function applyLoopbackNoProxy(env) {
     env.no_proxy = mergeNoProxyValue(env.no_proxy);
     return env;
 }
-export function resolveDefaultAdapterCommand(kind, options = {}) {
-    const platform = options.platform ?? process.platform;
-    if (kind !== "shell") {
-        return kind;
-    }
-    if (platform === "win32") {
-        return "powershell.exe";
-    }
-    const env = options.env ?? process.env;
-    for (const candidate of DEFAULT_UNIX_SHELL_CANDIDATES) {
-        if (resolveCommandPath(candidate, platform, env)) {
-            return candidate;
-        }
-    }
-    throw new Error(`No default shell executable was found on ${platform}. Tried: ${DEFAULT_UNIX_SHELL_CANDIDATES.join(", ")}. Use --cmd <executable>.`);
+export function resolveDefaultAdapterCommand(kind, _options = {}) {
+    return kind;
 }
-export function buildCliEnvironment(kind, options = {}) {
+export function buildCliEnvironment(_kind, options = {}) {
     const sourceEnv = options.env ?? process.env;
     const platform = options.platform ?? process.platform;
-    if (kind === "codex" || kind === "claude" || kind === "opencode") {
-        // 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",
-        };
-        if (platform === "win32" && !env.HOME && env.USERPROFILE) {
-            env.HOME = env.USERPROFILE;
-        }
-        return applyLoopbackNoProxy(env);
-    }
-    return {
+    // 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",
     };
+    if (platform === "win32" && !env.HOME && env.USERPROFILE) {
+        env.HOME = env.USERPROFILE;
+    }
+    return applyLoopbackNoProxy(env);
 }
 // 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.
@@ -732,72 +717,6 @@ export function buildPtySpawnOptions(params) {
     }
     return options;
 }
-export function normalizeShellCommandName(command) {
-    return path.parse(path.basename(command)).name.toLowerCase();
-}
-export function resolveShellRuntime(command, options = {}) {
-    const platform = options.platform ?? process.platform;
-    const name = normalizeShellCommandName(command);
-    if (name === "powershell" || name === "pwsh") {
-        return {
-            family: "powershell",
-            launchArgs: platform === "win32"
-                ? ["-NoLogo", "-NoProfile", "-ExecutionPolicy", "Bypass", "-NoExit"]
-                : ["-NoLogo", "-NoProfile", "-NoExit"],
-        };
-    }
-    if (POSIX_SHELL_NAMES.has(name)) {
-        return {
-            family: "posix",
-            launchArgs: ["-i"],
-        };
-    }
-    throw new Error(`Unsupported shell executable for shell adapter: ${command}. Supported shells: powershell, pwsh, bash, zsh, sh, dash, ksh.`);
-}
-export function escapePowerShellString(text) {
-    return text.replace(/`/g, "``").replace(/"/g, '`"');
-}
-export function escapePosixShellString(text) {
-    return `'${text.replace(/'/g, `'"'"'`)}'`;
-}
-export function buildShellProfileCommand(profilePath, family) {
-    const resolved = path.resolve(profilePath);
-    if (family === "powershell") {
-        return `. "${escapePowerShellString(resolved)}"`;
-    }
-    return `. ${escapePosixShellString(resolved)}`;
-}
-export function buildShellInputPayload(text, family, completionMarker = "__WECHAT_BRIDGE_DONE__") {
-    if (family === "powershell") {
-        const encodedCommand = Buffer.from(text, "utf8").toString("base64");
-        const script = [
-            "$__wechatBridgePreviousErrorActionPreference = $ErrorActionPreference",
-            "$ErrorActionPreference = 'Continue'",
-            "$global:LASTEXITCODE = 0",
-            "try {",
-            `  $decoded = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String("${escapePowerShellString(encodedCommand)}"))`,
-            "  $scriptBlock = [scriptblock]::Create($decoded)",
-            "  & $scriptBlock",
-            "} catch {",
-            "  Write-Error $_",
-            "  $global:LASTEXITCODE = 1",
-            "} finally {",
-            "  if (-not ($global:LASTEXITCODE -is [int])) { $global:LASTEXITCODE = 0 }",
-            `  Write-Output "${escapePowerShellString(completionMarker)}:$global:LASTEXITCODE"`,
-            "  $ErrorActionPreference = $__wechatBridgePreviousErrorActionPreference",
-            "}",
-            "",
-        ];
-        return `${script.join("\r")}\r`;
-    }
-    const script = [
-        text,
-        "__wechat_bridge_status=$?",
-        `printf '%s:%s\\n' ${escapePosixShellString(completionMarker)} "$__wechat_bridge_status"`,
-        "",
-    ];
-    return `${script.join("\r")}\r`;
-}
 export async function reserveLocalPort() {
     return await new Promise((resolve, reject) => {
         const server = net.createServer();
@@ -1170,7 +1089,8 @@ export function resolveSpawnTarget(command, kind, options = {}) {
         return { file: trimmed, args: [...forwardArgs] };
     }
     const resolved = resolveCommandPath(trimmed, platform, env) ?? trimmed;
-    if (platform !== "win32" || (kind !== "codex" && kind !== "claude" && kind !== "opencode")) {
+    if (platform !== "win32" ||
+        (kind !== "codex" && kind !== "claude" && kind !== "opencode" && kind !== "pi")) {
         return { file: resolved, args: [...forwardArgs] };
     }
     const bundledExe = kind === "codex" || kind === "claude"

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

@@ -8,9 +8,24 @@ export async function forwardWechatFinalReply(params) {
     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.
-        for (const chunk of splitWechatTextIntoChunks(visibleText)) {
-            const sent = await sender.sendText(chunk);
+        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;
             }
         }

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

@@ -56,9 +56,14 @@ export function isWechatDaemonCommandLineForCwd(commandLine, cwd) {
  *   opencode serve --port 12345 --hostname 127.0.0.1
  *   opencode.exe serve --port 12345
  * Also matches wrapper invocations (opencode.cmd / opencode.bat) on Windows.
+ *
+ * `serve` must be the first subcommand token after the executable so that
+ * unrelated command lines merely containing both words (e.g.
+ * `node opencode-lint/serve.js` or `mytool --theme opencode --mode serve`)
+ * are not reaped as orphans.
  */
 export function isOpencodeServeCommandLine(commandLine) {
-    return /\bopencode(?:\.exe|\.cmd|\.bat)?\b.*\bserve\b/i.test(commandLine);
+    return /\bopencode(?:\.exe|\.cmd|\.bat)?["']?\s+serve\b/i.test(commandLine);
 }
 /**
  * Detects `opencode attach` command lines spawned by the local OpenCode companion.
@@ -67,7 +72,7 @@ export function isOpencodeServeCommandLine(commandLine) {
  *   opencode.exe attach http://127.0.0.1:12345 --session ses_123
  */
 export function isOpencodeAttachCommandLine(commandLine) {
-    return /\bopencode(?:\.exe|\.cmd|\.bat)?\b.*\battach\b/i.test(commandLine);
+    return /\bopencode(?:\.exe|\.cmd|\.bat)?["']?\s+attach\b/i.test(commandLine);
 }
 function normalizeBridgeProcessRecord(value) {
     if (!isRecord(value)) {
@@ -158,7 +163,8 @@ function listWindowsBridgeProcesses(currentPid = process.pid) {
         "Bypass",
         "-Command",
         [
-            "$ErrorActionPreference='Stop'",
+            // Trailing semicolon required — see the note in listAllProcessesRaw.
+            "$ErrorActionPreference='Stop';",
             "Get-CimInstance Win32_Process",
             "| Where-Object { $_.CommandLine }",
             "| Select-Object ProcessId,ParentProcessId,Name,CommandLine",
@@ -236,7 +242,11 @@ function listAllProcessesRaw(currentPid = process.pid) {
             "Bypass",
             "-Command",
             [
-                "$ErrorActionPreference='Stop'",
+                // Statement separator required: without the trailing semicolon
+                // PowerShell parses the preference assignment and the first command
+                // as one statement and fails with a ParserError, silently
+                // returning an empty process list on every probe.
+                "$ErrorActionPreference='Stop';",
                 "Get-CimInstance Win32_Process",
                 "| Where-Object { $_.CommandLine }",
                 "| Select-Object ProcessId,ParentProcessId,Name,CommandLine",

package/dist/bridge/bridge-state.js

@@ -1,6 +1,8 @@
 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 { writeJsonFileAtomic } from "../utils/atomic-file.js";
+import { getProcessRecordByPid, isWechatBridgeCommandLine, } from "./bridge-process-reaper.js";
 const ORPHAN_LOCK_RECLAIM_TIMEOUT_MS = 2_000;
 const ORPHAN_LOCK_RECLAIM_POLL_MS = 100;
 export function resolveRestorableSharedSessionId(persisted, options) {
@@ -59,6 +61,7 @@ export function normalizeBridgeLockPayload(value) {
     const adapter = record.adapter === "codex" ||
         record.adapter === "claude" ||
         record.adapter === "opencode" ||
+        record.adapter === "pi" ||
         record.adapter === "shell"
         ? record.adapter
         : null;
@@ -136,7 +139,37 @@ export function evaluateBridgeRuntimeOwnership(params) {
 function buildLockConflictError(lock) {
     return new Error(`Another bridge instance is already running (pid=${lock.pid}, instanceId=${lock.instanceId}, adapter=${lock.adapter}, cwd=${lock.cwd}, startedAt=${lock.startedAt}, lifecycle=${lock.lifecycle}). Stop it before starting a new bridge.`);
 }
+/**
+ * Check whether the process currently holding a stale lock is still a
+ * wechat-bridge process. OS pid reuse can hand the recorded pid to an
+ * unrelated process; terminating that pid would kill an innocent process.
+ *
+ * Returns "bridge" when the command line matches a bridge, "foreign" when the
+ * pid is alive but belongs to something else, and "unknown" when the command
+ * line could not be resolved (probe failure, restricted permissions).
+ */
+export function classifyLockHolderProcess(pid) {
+    if (!isPidAlive(pid)) {
+        return "unknown";
+    }
+    const record = getProcessRecordByPid(pid);
+    if (!record) {
+        return "unknown";
+    }
+    return isWechatBridgeCommandLine(record.commandLine) ? "bridge" : "foreign";
+}
 function tryTerminateOrphanedBridge(lock) {
+    const holderKind = classifyLockHolderProcess(lock.pid);
+    if (holderKind === "foreign") {
+        // The lock-holding bridge is gone and its pid was reused by an unrelated
+        // process. Reclaim the lock without killing that process.
+        return true;
+    }
+    if (holderKind === "unknown") {
+        // Could not confirm the pid still belongs to a bridge. Do not risk
+        // killing an innocent process; keep the conflict error instead.
+        return false;
+    }
     try {
         process.kill(lock.pid);
     }
@@ -294,13 +327,9 @@ export class BridgeStateStore {
         }
     }
     writeAtomicJsonFile(filePath, value) {
-        ensureChannelDataDir();
-        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);
+        writeJsonFileAtomic(filePath, value);
     }
     save() {
         this.writeAtomicJsonFile(this.stateFilePath, this.state);
@@ -310,7 +339,14 @@ export class BridgeStateStore {
         if (existing &&
             existing.pid !== process.pid &&
             isPidAlive(existing.pid)) {
-            if (shouldAutoReclaimBridgeLock(existing)) {
+            const holderKind = classifyLockHolderProcess(existing.pid);
+            if (holderKind === "foreign") {
+                // The recorded bridge exited and the OS reused its pid for an
+                // unrelated process. The lock is stale: reclaim it instead of
+                // dead-locking new bridges on a phantom holder.
+                this.appendLog(`stale_lock_pid_reuse: pid=${existing.pid} instanceId=${existing.instanceId} adapter=${existing.adapter} cwd=${existing.cwd}`);
+            }
+            else if (shouldAutoReclaimBridgeLock(existing)) {
                 this.appendLog(`lock_reclaim_attempt: pid=${existing.pid} instanceId=${existing.instanceId} adapter=${existing.adapter} cwd=${existing.cwd}`);
                 if (tryTerminateOrphanedBridge(existing)) {
                     this.appendLog(`lock_reclaimed: pid=${existing.pid} instanceId=${existing.instanceId} adapter=${existing.adapter} cwd=${existing.cwd}`);