cli-wechat-bridge 1.0.7 → 1.1.0

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":
@@ -268,8 +293,8 @@ function formatPromptByteSize(bytes) {
 }
 function formatWechatInboundAttachmentPrompt(attachments) {
     const lines = [
-        "[WeChat inbound attachments]",
-        "The user sent attachment files through WeChat. They have been saved locally. Read the local paths directly if the user's request requires inspecting them.",
+        "[WeChat inbound attachments — ACTION REQUIRED]",
+        "The user sent the following files through WeChat. You MUST use the Read tool to read each file path below BEFORE responding. Do NOT skip reading these files — the user expects you to see their content (including images).",
     ];
     attachments.forEach((attachment, index) => {
         const sizeText = formatPromptByteSize(attachment.sizeBytes);
@@ -280,6 +305,8 @@ function formatWechatInboundAttachmentPrompt(attachments) {
         ].filter(Boolean);
         lines.push(`${index + 1}. ${metadata.join(" ")} path=${attachment.path}`);
     });
+    lines.push("");
+    lines.push("Remember: Read each path above with the Read tool NOW. Images are viewable via Read.");
     return lines.join("\n");
 }
 export function buildWechatInboundPrompt(text, attachments = []) {
@@ -383,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,
@@ -995,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) {
@@ -1008,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, '""')}"`;
 }
@@ -71,6 +63,11 @@ export function buildClaudeHookSettings(command) {
             ],
             Stop: [hook],
             StopFailure: [hook],
+            PreToolUse: [hook],
+            PostToolUse: [hook],
+            PreCompact: [hook],
+            PostCompact: [hook],
+            SubagentStop: [hook],
         },
     };
 }
@@ -85,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");
     }
@@ -99,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");
 }
@@ -209,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-link.js

@@ -210,10 +210,16 @@ export function sendLocalCompanionMessage(socket, message) {
         return false;
     }
 }
+const MAX_IPC_BUFFER_SIZE = 1_048_576; // 1MB
 export function attachLocalCompanionMessageListener(socket, onMessage) {
     let buffer = "";
     const onData = (chunk) => {
         buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        if (buffer.length > MAX_IPC_BUFFER_SIZE) {
+            socket.destroy(new Error("IPC buffer overflow: exceeded 1MB without complete frame"));
+            buffer = "";
+            return;
+        }
         while (true) {
             const newlineIndex = buffer.indexOf("\n");
             if (newlineIndex < 0) {

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/daemon-link.js

@@ -80,10 +80,16 @@ export function sendDaemonResponse(socket, id, response) {
         return false;
     }
 }
+const MAX_IPC_BUFFER_SIZE = 1_048_576; // 1MB
 export function attachDaemonRequestListener(socket, onRequest) {
     let buffer = "";
     const onData = (chunk) => {
         buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        if (buffer.length > MAX_IPC_BUFFER_SIZE) {
+            socket.destroy(new Error("IPC buffer overflow: exceeded 1MB without complete frame"));
+            buffer = "";
+            return;
+        }
         while (true) {
             const newlineIndex = buffer.indexOf("\n");
             if (newlineIndex < 0) {

package/dist/daemon/emoji-bindings.js

@@ -0,0 +1,111 @@
+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",
+    "[拥抱]": "/claude",
+    "[强]": "/codex",
+    "[胜利]": "/opencode",
+    "[再见]": "/daemon-stop",
+};
+let bindingsMap = null;
+function buildMap(bindings) {
+    const map = new Map();
+    for (const [emoji, command] of Object.entries(bindings)) {
+        map.set(emoji.toLowerCase(), command);
+    }
+    return map;
+}
+export function loadEmojiBindings() {
+    if (bindingsMap) {
+        return bindingsMap;
+    }
+    try {
+        if (fs.existsSync(EMOJI_BINDINGS_FILE)) {
+            const raw = JSON.parse(fs.readFileSync(EMOJI_BINDINGS_FILE, "utf-8"));
+            if (raw.bindings && typeof raw.bindings === "object") {
+                bindingsMap = buildMap(raw.bindings);
+                return bindingsMap;
+            }
+        }
+    }
+    catch {
+        // Fall through to defaults on parse error.
+    }
+    bindingsMap = buildMap(DEFAULT_EMOJI_BINDINGS);
+    return bindingsMap;
+}
+export function saveEmojiBindings(map) {
+    const bindings = {};
+    for (const [emoji, command] of map) {
+        bindings[emoji] = command;
+    }
+    const data = { bindings };
+    fs.writeFile(EMOJI_BINDINGS_FILE, JSON.stringify(data, null, 2) + "\n", () => { });
+}
+export function setBinding(emoji, command) {
+    const map = loadEmojiBindings();
+    map.set(emoji.toLowerCase(), command);
+    bindingsMap = map;
+    saveEmojiBindings(map);
+}
+export function removeBinding(emoji) {
+    const map = loadEmojiBindings();
+    const key = emoji.toLowerCase();
+    if (!map.has(key)) {
+        return false;
+    }
+    map.delete(key);
+    bindingsMap = map;
+    saveEmojiBindings(map);
+    return true;
+}
+export function listBindings() {
+    return loadEmojiBindings();
+}
+export function resolveEmojiCommand(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("[")) {
+        return null;
+    }
+    const map = loadEmojiBindings();
+    const lower = trimmed.toLowerCase();
+    for (const [emoji, command] of map) {
+        if (lower.startsWith(emoji)) {
+            const remainder = trimmed.slice(emoji.length).trim();
+            return { command, remainder };
+        }
+    }
+    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")}`;
+}