@unlinearity/cli-wechat-bridge 1.0.9 → 1.1.0

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

@@ -2,7 +2,8 @@ import fs from "node:fs";
 import path from "node:path";
 import net from "node:net";
 import { fileURLToPath } from "node:url";
-import { spawnSync } from "node:child_process";
+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 { getNotificationThreadId, isRecord, } from "./bridge-adapter-common.js";
@@ -1214,3 +1215,102 @@ export function resolveSpawnTarget(command, kind, options = {}) {
     }
     return { file: resolved, args: [...forwardArgs] };
 }
+export function spawnFallbackProcess(file, args, options) {
+    const child = spawn(file, args, {
+        cwd: options.cwd,
+        env: { ...options.env, TERM: "dumb" },
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: false,
+        shell: false,
+    });
+    if (!child.pid) {
+        throw new Error(`Failed to spawn fallback process: ${file}`);
+    }
+    const dataListeners = [];
+    const exitListeners = [];
+    child.stdout?.on("data", (chunk) => {
+        const text = chunk.toString("utf8");
+        for (const listener of dataListeners) {
+            listener(text);
+        }
+    });
+    child.stderr?.on("data", (chunk) => {
+        const text = chunk.toString("utf8");
+        for (const listener of dataListeners) {
+            listener(text);
+        }
+    });
+    child.on("exit", (code, signal) => {
+        const exitCode = code ?? (signal ? 128 : 1);
+        for (const listener of exitListeners) {
+            listener({ exitCode });
+        }
+    });
+    return {
+        pid: child.pid,
+        write(data) {
+            child.stdin?.write(data);
+        },
+        kill(signal) {
+            try {
+                if (process.platform === "win32") {
+                    spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+                        stdio: "ignore",
+                        windowsHide: true,
+                    });
+                }
+                else {
+                    child.kill(signal);
+                }
+            }
+            catch {
+                // Best effort.
+            }
+        },
+        onData(callback) {
+            dataListeners.push(callback);
+            return {
+                dispose() {
+                    const index = dataListeners.indexOf(callback);
+                    if (index >= 0)
+                        dataListeners.splice(index, 1);
+                },
+            };
+        },
+        onExit(callback) {
+            exitListeners.push(callback);
+            return {
+                dispose() {
+                    const index = exitListeners.indexOf(callback);
+                    if (index >= 0)
+                        exitListeners.splice(index, 1);
+                },
+            };
+        },
+    };
+}
+export function buildSpawnDiagnostic(error, spawnTarget, platform = process.platform) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const target = spawnTarget ? spawnTarget.file : "(unknown)";
+    const lines = [
+        t("spawn.diagnostic.title", { target, error: errorMessage }),
+        t("spawn.diagnostic.fixesHeader"),
+    ];
+    if (errorMessage.includes("posix_spawnp") || errorMessage.includes("node-pty")) {
+        lines.push(t("spawn.diagnostic.nodePty"));
+        if (platform === "darwin") {
+            lines.push(t("spawn.diagnostic.xcode"));
+        }
+    }
+    else if (errorMessage.includes("ENOENT") || errorMessage.includes("spawn")) {
+        lines.push(t("spawn.diagnostic.notFound", { target }));
+    }
+    else {
+        lines.push(t("spawn.diagnostic.generic"));
+    }
+    lines.push(t("spawn.diagnostic.nodeVersion"));
+    if (platform === "win32") {
+        lines.push(t("spawn.diagnostic.winAdmin"));
+    }
+    return lines.join("\n");
+}

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

@@ -67,7 +67,7 @@ export class ShellAdapter extends AbstractPtyAdapter {
             throw new Error("shell is still working. Wait for the current reply or use /stop.");
         }
         if (this.pendingApproval || this.state.status === "awaiting_approval") {
-            throw new Error("A shell approval request is pending. Reply with /confirm <code> or /deny.");
+            throw new Error("A shell approval request is pending. Reply with /confirm or /deny.");
         }
         const rejectionMessage = getInteractiveShellCommandRejectionMessage(text);
         if (rejectionMessage) {

package/dist/bridge/bridge-utils.js

@@ -1,3 +1,4 @@
+import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 const ANSI_ESCAPE_RE = 
@@ -122,6 +123,34 @@ export function truncatePreview(text, maxLength = 140) {
     }
     return `${normalized.slice(0, Math.max(0, maxLength - 3))}...`;
 }
+export function isThinkingForwardEnabled() {
+    if (process.env.CLI_BRIDGE_THINKING_FORWARD === "1") {
+        return true;
+    }
+    try {
+        const accountPath = process.env.CLI_BRIDGE_DATA_DIR
+            ? path.join(process.env.CLI_BRIDGE_DATA_DIR, "account.json")
+            : path.join(os.homedir(), ".cli-bridge", "account.json");
+        if (!fs.existsSync(accountPath))
+            return false;
+        const raw = fs.readFileSync(accountPath, "utf8");
+        const data = JSON.parse(raw);
+        return data.enableThinkingForward === true;
+    }
+    catch {
+        return false;
+    }
+}
+export function formatThinkingForWechat(text, maxLength = 500) {
+    const normalized = normalizeOutput(text).trim();
+    if (!normalized) {
+        return "";
+    }
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, Math.max(0, maxLength - 3))}...`;
+}
 export function buildOneTimeCode(length = 6) {
     const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
     let code = "";
@@ -157,8 +186,10 @@ export function parseSystemCommand(text) {
         case "/reset":
             return { type: "reset" };
         case "/confirm":
-            return argument ? { type: "confirm", code: argument } : null;
+        case "/yes":
+            return { type: "confirm" };
         case "/deny":
+        case "/no":
             return { type: "deny" };
         case "/answer":
             return argument ? { type: "answer", raw: argument } : null;
@@ -171,19 +202,13 @@ export function parseWechatControlCommand(text, options) {
     if (systemCommand) {
         return systemCommand;
     }
-    if (options.adapter !== "claude") {
+    if (!options.hasPendingConfirmation) {
         return null;
     }
     const normalized = text.trim().toLowerCase();
     if (!normalized) {
         return null;
     }
-    if (normalized === "/confirm") {
-        return { type: "confirm" };
-    }
-    if (!options.hasPendingConfirmation) {
-        return null;
-    }
     switch (normalized) {
         case "confirm":
         case "yes":
@@ -385,7 +410,7 @@ const HIGH_RISK_PATTERNS = [
     /\brmdir\b/i,
     /\bdel\b/i,
     /\berase\b/i,
-    /\bformat\b/i,
+    /\bformat\b(?!-)/i,
     /\bshutdown\b/i,
     /\bstop-computer\b/i,
     /\brestart-computer\b/i,
@@ -997,10 +1022,9 @@ export function formatApprovalMessage(pending, adapterState) {
     return [
         `${pending.source === "shell" ? "Shell" : "CLI"} approval is required.`,
         `adapter: ${adapterState.kind}`,
-        `code: ${pending.code}`,
         `summary: ${pending.summary}`,
         `target: ${pending.commandPreview}`,
-        "Reply with /confirm <code> to continue or /deny to reject.",
+        "Reply with /confirm or /yes to continue, /deny or /no to reject.",
     ].join("\n");
 }
 export function formatPendingApprovalReminder(pending, adapterState) {
@@ -1010,7 +1034,7 @@ export function formatPendingApprovalReminder(pending, adapterState) {
             : pending.commandPreview;
         return `Approval is pending for ${truncatePreview(target, 140)}. Reply with /confirm, confirm, or yes to continue, or /deny, deny, or no to reject.`;
     }
-    return `Approval is pending for ${pending.commandPreview}. Reply with /confirm ${pending.code} or /deny.`;
+    return `Approval is pending for ${pending.commandPreview}. Reply with /confirm or /deny.`;
 }
 function formatUserInputQuestionLabel(question, index) {
     return `${index + 1}. ${question.header} [id: ${question.id}]`;

package/dist/bridge/claude-hooks.js

@@ -6,14 +6,6 @@ const FILE_MUTATION_TOOL_NAMES = new Set([
     "MultiEdit",
     "NotebookEdit",
 ]);
-const LOW_RISK_READ_TOOL_NAMES = new Set([
-    "Glob",
-    "Grep",
-    "LS",
-    "NotebookRead",
-    "Read",
-    "TodoRead",
-]);
 function quoteWindowsCommandArg(value) {
     return `"${value.replace(/"/g, '""')}"`;
 }
@@ -90,13 +82,15 @@ export function buildClaudeHookScript(params) {
             params.runtimeExecPath,
             ...runtimeArgs,
         ].map(quoteWindowsCommandArg).join(" ");
+        const stderrRedirect = params.hookErrorLogPath
+            ? `2>>${quoteWindowsCommandArg(params.hookErrorLogPath)}`
+            : "2>nul";
         return [
             "@echo off",
             "setlocal",
             `set "CLAUDE_WECHAT_HOOK_PORT=${params.hookPort}"`,
             `set "CLAUDE_WECHAT_HOOK_TOKEN=${params.hookToken}"`,
-            // Claude reads hook decisions from stdout, so only stderr can be discarded here.
-            `${command} 2>nul`,
+            `${command} ${stderrRedirect}`,
             "exit /b 0",
         ].join("\r\n");
     }
@@ -104,12 +98,14 @@ export function buildClaudeHookScript(params) {
         params.runtimeExecPath,
         ...runtimeArgs,
     ].map(quotePosixCommandArg).join(" ");
+    const stderrRedirect = params.hookErrorLogPath
+        ? `2>>${quotePosixCommandArg(params.hookErrorLogPath)}`
+        : "2>/dev/null";
     return [
         "#!/bin/sh",
         `export CLAUDE_WECHAT_HOOK_PORT=${quotePosixCommandArg(String(params.hookPort))}`,
         `export CLAUDE_WECHAT_HOOK_TOKEN=${quotePosixCommandArg(params.hookToken)}`,
-        // Claude reads hook decisions from stdout, so only stderr can be discarded here.
-        `${command} 2>/dev/null || true`,
+        `${command} ${stderrRedirect} || true`,
         "exit 0",
     ].join("\n");
 }
@@ -214,15 +210,12 @@ export function getClaudePermissionAutoResponse(payload) {
     if (!toolName) {
         return null;
     }
-    if (LOW_RISK_READ_TOOL_NAMES.has(toolName)) {
+    if (toolName !== "Bash") {
         return {
             action: "confirm",
             reason: `low-risk ${toolName} permission`,
         };
     }
-    if (toolName !== "Bash") {
-        return null;
-    }
     const command = getClaudeToolInputString(payload, "command").trim();
     if (!command || isHighRiskShellCommand(command)) {
         return null;

package/dist/bridge/wechat-bridge.js

@@ -2,16 +2,18 @@
 import path from "node:path";
 import { resolveDefaultAdapterCommand, } from "./bridge-adapters.js";
 import { delay } from "./bridge-adapters.shared.js";
+import { t } from "../i18n/index.js";
 import { BridgeController } from "./bridge-controller.js";
 import { forwardWechatFinalReply } from "./bridge-final-reply.js";
 import { ensureWechatCredentials } from "../wechat/setup.js";
 import { BridgeStateStore } from "./bridge-state.js";
 import { reapOrphanedOpencodeProcesses, reapPeerBridgeProcesses } from "./bridge-process-reaper.js";
 import { createRuntimeHost } from "../runtime/create-runtime-host.js";
-import { buildWechatInboundPrompt, buildOneTimeCode, formatApprovalMessage, formatPendingApprovalReminder, formatPendingUserInputReminder, formatDuration, formatMirroredUserInputMessage, formatSessionSwitchMessage, formatStatusReport, formatTaskFailedMessage, formatUserInputRequestMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parsePendingUserInputAnswerCommand, parseWechatControlCommand, truncatePreview, } from "./bridge-utils.js";
+import { buildWechatInboundPrompt, buildOneTimeCode, formatApprovalMessage, formatPendingApprovalReminder, formatPendingUserInputReminder, formatDuration, formatMirroredUserInputMessage, formatSessionSwitchMessage, formatStatusReport, formatTaskFailedMessage, formatThinkingForWechat, formatUserInputRequestMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parsePendingUserInputAnswerCommand, parseWechatControlCommand, truncatePreview, } from "./bridge-utils.js";
 import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, WeChatTransport, describeWechatTransportError, isWechatContextTokenStaleError, } from "../wechat/wechat-transport.js";
 import { checkForUpdate, formatUpdateMessage, } from "../utils/version-checker.js";
 import { clearDaemonEndpoint, isDaemonEndpointAlive, readDaemonEndpoint, } from "../daemon/daemon-link.js";
+import { formatBindCommandUsage, formatBindingsListMessage, isBindCommandPrefix, listBindings, loadEmojiBindings, parseEmojiBindingsCommand, removeBinding, resolveEmojiCommand, setBinding, } from "../daemon/emoji-bindings.js";
 const POLL_RETRY_BASE_MS = 1_000;
 const POLL_RETRY_MAX_MS = 30_000;
 const PARENT_PROCESS_POLL_MS = 5_000;
@@ -608,6 +610,13 @@ async function main() {
         else if (options.adapter === "shell") {
             log("Shell mode runs as a headless remote executor for non-interactive commands and scripts.");
         }
+        loadEmojiBindings();
+        const welcomeText = t("bridge.welcome", {
+            adapter: options.adapter,
+            cwd: options.cwd,
+            bindings: formatBindingsListMessage(listBindings()),
+        });
+        await queueWechatMessage(credentials.userId, welcomeText);
         while (true) {
             if (!ensureRuntimeOwnership()) {
                 break;
@@ -792,6 +801,18 @@ function wireAdapterEvents(params) {
                     }));
                 }
                 break;
+            case "thinking":
+                updateLastOutputAt();
+                if (event.text) {
+                    const thinkingPreview = formatThinkingForWechat(event.text, 500);
+                    if (thinkingPreview) {
+                        stateStore.appendLog(`thinking: ${thinkingPreview}`);
+                        trackWechatForwardTask((async () => {
+                            await queueWechatMessage(authorizedUserId, `思考: ${thinkingPreview}`, "thinking");
+                        })());
+                    }
+                }
+                break;
             case "approval_required":
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     const pending = toPendingApproval(event.request);
@@ -911,17 +932,49 @@ function formatInboundMessagePreview(message) {
     return "(empty)";
 }
 async function handleInboundMessage(params) {
-    const { message, options, stateStore, adapter, queueWechatMessage, outputBatcher, deferInboundMessage, } = params;
+    let { message, } = params;
+    const { options, stateStore, adapter, queueWechatMessage, outputBatcher, deferInboundMessage, } = params;
     const state = stateStore.getState();
+    if (message.senderId !== state.authorizedUserId) {
+        await queueWechatMessage(message.senderId, "Unauthorized. This bridge only accepts messages from the configured WeChat owner.");
+        return null;
+    }
+    // Emoji resolution: rewrite message text if it starts with a bound emoji
+    const emojiMatch = resolveEmojiCommand(message.text);
+    if (emojiMatch) {
+        const rewritten = emojiMatch.remainder
+            ? `${emojiMatch.command} ${emojiMatch.remainder}`
+            : emojiMatch.command;
+        message = { ...message, text: rewritten };
+    }
+    // Emoji binding management commands
+    const bindingsCmd = parseEmojiBindingsCommand(message.text);
+    if (bindingsCmd) {
+        switch (bindingsCmd.type) {
+            case "list":
+                await queueWechatMessage(message.senderId, formatBindingsListMessage(listBindings()));
+                break;
+            case "bind":
+                setBinding(bindingsCmd.emoji, bindingsCmd.command);
+                await queueWechatMessage(message.senderId, `Bound ${bindingsCmd.emoji} → ${bindingsCmd.command}`);
+                break;
+            case "unbind": {
+                const removed = removeBinding(bindingsCmd.emoji);
+                await queueWechatMessage(message.senderId, removed ? `Unbound ${bindingsCmd.emoji}` : `No binding found for ${bindingsCmd.emoji}`);
+                break;
+            }
+        }
+        return null;
+    }
+    if (isBindCommandPrefix(message.text)) {
+        await queueWechatMessage(message.senderId, formatBindCommandUsage());
+        return null;
+    }
     const systemCommand = parseWechatControlCommand(message.text, {
         adapter: options.adapter,
         hasPendingConfirmation: Boolean(state.pendingConfirmation),
         hasPendingUserInput: Boolean(state.pendingUserInput),
     });
-    if (message.senderId !== state.authorizedUserId) {
-        await queueWechatMessage(message.senderId, "Unauthorized. This bridge only accepts messages from the configured WeChat owner.");
-        return null;
-    }
     switch (systemCommand?.type) {
         case "status":
             await queueWechatMessage(message.senderId, formatStatusReport(stateStore.getState(), adapter.getState()));
@@ -979,10 +1032,6 @@ async function handleInboundMessage(params) {
                 await queueWechatMessage(message.senderId, "No pending approval request.");
                 return null;
             }
-            if (options.adapter !== "claude" && pending.code !== systemCommand.code) {
-                await queueWechatMessage(message.senderId, "Confirmation code did not match.");
-                return null;
-            }
             const confirmed = await adapter.resolveApproval("confirm");
             if (!confirmed) {
                 await queueWechatMessage(message.senderId, "The worker could not apply this approval request.");

package/dist/companion/local-companion.js

@@ -127,6 +127,7 @@ export async function runLocalCompanion(options) {
         }
         socket.removeAllListeners("close");
         socket.removeAllListeners("error");
+        socket.on("error", () => { });
         if (destroy) {
             try {
                 socket.destroy();

package/dist/daemon/emoji-bindings.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import { EMOJI_BINDINGS_FILE } from "../wechat/channel-config.js";
+import { t } from "../i18n/index.js";
 export const DEFAULT_EMOJI_BINDINGS = {
     "[OK]": "/confirm",
     "[闭嘴]": "/stop",
@@ -78,3 +79,33 @@ export function resolveEmojiCommand(text) {
     }
     return null;
 }
+export function parseEmojiBindingsCommand(text) {
+    const trimmed = text.trim();
+    const lower = trimmed.toLowerCase();
+    if (lower === "/bindings") {
+        return { type: "list" };
+    }
+    const bindMatch = trimmed.match(/^\/bind\s+(\[[^\]]+\])\s+(.+)$/i);
+    if (bindMatch) {
+        return { type: "bind", emoji: bindMatch[1], command: bindMatch[2].trim() };
+    }
+    const unbindMatch = trimmed.match(/^\/unbind\s+(\[[^\]]+\])$/i);
+    if (unbindMatch) {
+        return { type: "unbind", emoji: unbindMatch[1] };
+    }
+    return null;
+}
+export function isBindCommandPrefix(text) {
+    const lower = text.trim().toLowerCase();
+    return lower.startsWith("/bind") || lower.startsWith("/unbind");
+}
+export function formatBindCommandUsage() {
+    return t("binding.usage");
+}
+export function formatBindingsListMessage(map) {
+    if (map.size === 0) {
+        return t("binding.listEmpty");
+    }
+    const lines = Array.from(map.entries()).map(([emoji, command]) => `${emoji} → ${command}`);
+    return `${t("binding.listHeader")}\n${lines.join("\n")}`;
+}