cli-wechat-bridge 1.0.7 → 1.1.0

package/README.md

@@ -10,7 +10,7 @@
   <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="License" src="https://img.shields.io/npm/l/cli-wechat-bridge?label=License&style=for-the-badge&color=7c3aed&labelColor=1c1917">
+  <img alt="License" src="https://img.shields.io/badge/License-AGPL--3.0-7c3aed?style=for-the-badge&labelColor=1c1917">
 </a>
 </p>
 
@@ -305,9 +305,44 @@ wechat-claude-start --model sonnet --dangerously-skip-permissions
 | `/new` 或 `/new-session` | OpenCode 模式下新建 session |
 | `/confirm` / `/deny` | 处理 CLI 权限请求；需要一次性 code 的请求会在消息中提示具体确认格式 |
 | `/daemon-stop` | daemon 模式下停止常驻进程 |
+| `/bindings` | 查看当前所有表情绑定 |
+| `/bind [表情] /命令` | 绑定表情到指定命令 |
+| `/unbind [表情]` | 解除指定表情的绑定 |
 
 说明：微信侧 `/resume` 目前暂时保持禁用；需要切换 Codex / Claude / OpenCode 会话时，优先在本地 companion 中使用原生 `/resume`、`/new` 或对应 CLI 命令，微信会跟随本地活动会话。
 
+### 表情绑定
+
+Daemon 模式支持将微信表情映射为命令，在微信中发送表情即可快速触发操作。（不过注意，第一次启动相关cli的时候，最好不要带消息，等启动完成再“表情+文本”快速给指定 cli 发送消息。
+
+![表情触发](docs/images/image-10.png)
+
+**默认绑定：**
+
+| 表情 | 命令 | 说明 |
+| --- | --- | --- |
+| `[OK]` | `/confirm` | 批准权限请求 |
+| `[闭嘴]` | `/stop` | 中断当前任务 |
+| `[拥抱]` | `/claude` | 切换到 Claude Code |
+| `[强]` | `/codex` | 切换到 Codex |
+| `[胜利]` | `/opencode` | 切换到 OpenCode |
+| `[再见]` | `/daemon-stop` | 停止 daemon |
+
+**管理命令：**
+
+```
+/bindings              查看当前所有绑定
+/bind [表情] /命令     绑定表情到命令，如 /bind [微笑] /status
+/unbind [表情]         解除绑定，如 /unbind [微笑]
+```
+
+**触发规则：**
+
+- 表情必须出现在消息开头才会触发（如 `[OK]` 触发，`你好[OK]` 不触发）；
+- 如果表情后面还有文本（如 `[拥抱]帮我写个脚本`），会先执行命令再将剩余文本作为消息转发；
+- 大小写不敏感（`[OK]` 和 `[ok]` 等价）；
+- 修改后立即生效并持久化到 `~/.cli-bridge/emoji-bindings.json`，重启 daemon 后保留。
+
 ## 工作区模型
 
 本项目采用“当前目录即当前工作区”的模型：
@@ -390,7 +425,19 @@ npm install -g cli-wechat-bridge@latest
 
 ## License
 
-[MIT](LICENSE.txt)
+本项目采用**双协议**授权：
+
+**开源协议：[AGPL-3.0](LICENSE.txt)**
+
+- 个人使用、学习、研究：完全免费
+- 修改和衍生作品必须以相同协议（AGPL-3.0）开源
+- 通过网络提供基于本项目的服务，也必须公开完整源代码
+
+**商业授权**
+
+如果你希望在闭源商业产品中使用本项目（不公开你的源代码），需要获得商业许可。请联系作者获取商业授权方案：
+
+- GitHub: [@UNLINEARITY](https://github.com/UNLINEARITY)
 
 <p align="center">
   <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=UNLINEARITY/CLI-WeChat-Bridge&type=timeline&legend=top-left">

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

@@ -3,9 +3,10 @@ import net from "node:net";
 import os from "node:os";
 import path from "node:path";
 import { buildLocalCompanionToken } from "../companion/local-companion-link.js";
+import { t } from "../i18n/index.js";
 import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
 import { buildClaudeFailureMessage, buildClaudeHookScript, buildClaudeHookSettings, buildClaudePermissionDecisionHookOutput, buildClaudePermissionApprovalRequest, extractClaudeAssistantMessageText, extractClaudeResumeConversationId, extractClaudeTranscriptFinalReply, findInjectedClaudePromptIndex, getClaudePermissionAutoResponse, getClaudeWechatOutboundAttachmentDenyMessage, normalizeClaudeAssistantMessage, parseClaudeHookPayload, } from "./claude-hooks.js";
-import { detectCliApproval, normalizeOutput, nowIso, truncatePreview, } from "./bridge-utils.js";
+import { detectCliApproval, isThinkingForwardEnabled, normalizeOutput, nowIso, truncatePreview, } from "./bridge-utils.js";
 import { AbstractPtyAdapter } from "./bridge-adapters.core.js";
 import * as shared from "./bridge-adapters.shared.js";
 const { CLAUDE_HOOK_LISTEN_HOST, CLAUDE_WECHAT_WORKING_NOTICE_DELAY_MS, DEFAULT_COLS, DEFAULT_ROWS, MODULE_DIR, buildClaudeCliArgs, delay, isClaudeInvalidResumeError, quotePosixCommandArg, quoteWindowsCommandArg, shouldIncludeClaudeNoAltScreen, } = shared;
@@ -90,6 +91,9 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     localTerminalInputListener = null;
     resizeListener = null;
     settingsFilePath = null;
+    hookErrorLogPath = null;
+    hookReceivedCount = 0;
+    hookHealthCheckTimer = null;
     pendingHookApprovals = new Map();
     recoveringInvalidResume = false;
     workingNoticeTimer = null;
@@ -98,6 +102,10 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     lastCompactCompletionAtMs = 0;
     startupOutputBuffer = "";
     hasAutoConfirmedWorkspaceTrustPrompt = false;
+    lastAutoApprovedPayload = null;
+    transcriptPollTimer = null;
+    transcriptTailOffset = 0;
+    polledTranscriptSessionId = null;
     constructor(options) {
         super(options);
         const shouldRestoreInitialSession = options.sessionStartMode !== "new";
@@ -163,7 +171,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             throw new Error("claude is still working. Wait for the current reply or use /stop.");
         }
         if (this.pendingApproval) {
-            throw new Error("A Claude approval request is pending. Reply with /confirm <code> or /deny.");
+            throw new Error("A Claude approval request is pending. Reply with /confirm or /deny.");
         }
         const normalizedText = normalizeOutput(text).trim();
         this.pendingInjectedInputs.push({
@@ -178,6 +186,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.pendingCliApprovalHints = null;
         this.clearWechatWorkingNotice(true);
         this.setStatus("busy");
+        this.startTranscriptThinkingWatch();
         this.writeToPty(this.buildRemoteInputPayload(text));
         await delay(CLAUDE_REMOTE_ENTER_DELAY_MS);
         this.writeToPty("\r");
@@ -200,6 +209,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.pendingCliApprovalHints = null;
         this.flushPendingClaudeHookApprovals();
         this.writeToPty("\u0003");
+        this.scheduleTaskComplete(shared.INTERRUPT_SETTLE_DELAY_MS);
         return true;
     }
     async reset() {
@@ -247,11 +257,34 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.writeToPty(input);
         return true;
     }
+    async resolveAllApprovals(action) {
+        let count = 0;
+        for (const requestId of Array.from(this.pendingHookApprovals.keys())) {
+            const pending = this.pendingHookApprovals.get(requestId);
+            if (pending) {
+                this.pendingHookApprovals.delete(requestId);
+                this.respondToClaudeHook(pending.socket, requestId, buildClaudePermissionDecisionHookOutput(action));
+                count++;
+            }
+        }
+        if (count > 0) {
+            this.clearWechatWorkingNotice();
+            this.pendingCliApprovalHints = null;
+            this.pendingApproval = null;
+            this.state.pendingApproval = null;
+            this.state.pendingApprovalOrigin = undefined;
+            this.setStatus("busy");
+            return count;
+        }
+        const ok = await this.resolveApproval(action);
+        return ok ? 1 : 0;
+    }
     async dispose() {
         this.detachLocalTerminal();
         this.clearWechatWorkingNotice(true);
         this.pendingCliApprovalHints = null;
         this.flushPendingClaudeHookApprovals();
+        this.stopTranscriptThinkingWatch();
         await super.dispose();
         await this.stopHookServer();
     }
@@ -270,6 +303,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     afterStart() {
         this.attachLocalTerminal();
         this.resizePtyToTerminal();
+        this.startHookHealthCheck();
     }
     handleData(rawText) {
         this.renderLocalOutput(rawText);
@@ -446,12 +480,15 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         const hookEntryPath = fs.existsSync(sourceHookEntryPath)
             ? sourceHookEntryPath
             : path.join(MODULE_DIR, "claude-hook.js");
+        const hookErrorLogPath = path.join(runtimeDir, "hook-error.log");
+        this.hookErrorLogPath = hookErrorLogPath;
         fs.writeFileSync(hookScriptPath, buildClaudeHookScript({
             platform: process.platform,
             runtimeExecPath: process.execPath,
             hookEntryPath,
             hookPort: this.hookPort,
             hookToken: this.hookToken,
+            hookErrorLogPath,
         }), "utf8");
         if (process.platform !== "win32") {
             fs.chmodSync(hookScriptPath, 0o755);
@@ -500,7 +537,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             return;
         }
         try {
-            this.pty.resize(process.stdout.columns || DEFAULT_COLS, process.stdout.rows || DEFAULT_ROWS);
+            this.pty.resize?.(process.stdout.columns || DEFAULT_COLS, process.stdout.rows || DEFAULT_ROWS);
         }
         catch {
             // Best effort resize sync.
@@ -546,6 +583,34 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             this.workingNoticeSent = false;
         }
     }
+    startHookHealthCheck() {
+        this.hookReceivedCount = 0;
+        this.clearHookHealthCheck();
+        this.hookHealthCheckTimer = setTimeout(() => {
+            this.hookHealthCheckTimer = null;
+            if (this.hookReceivedCount === 0 && !this.shuttingDown) {
+                const logHint = this.hookErrorLogPath
+                    ? t("hook.healthCheck.logHint", { logPath: this.hookErrorLogPath })
+                    : "";
+                this.emit({
+                    type: "stdout",
+                    text: [
+                        t("hook.healthCheck.warning"),
+                        logHint,
+                        t("hook.healthCheck.fixes"),
+                    ].filter(Boolean).join("\n"),
+                    timestamp: nowIso(),
+                });
+            }
+        }, 15_000);
+        this.hookHealthCheckTimer.unref?.();
+    }
+    clearHookHealthCheck() {
+        if (this.hookHealthCheckTimer) {
+            clearTimeout(this.hookHealthCheckTimer);
+            this.hookHealthCheckTimer = null;
+        }
+    }
     emitClaudeNotice(text, level = "info") {
         const normalized = normalizeOutput(text).trim();
         if (!normalized) {
@@ -566,6 +631,9 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         }
         return `${CLAUDE_BRACKETED_PASTE_START}${normalizedText}${CLAUDE_BRACKETED_PASTE_END}`;
     }
+    // Fallback heuristic for older Claude Code versions that lack PostCompact hooks.
+    // The structured PostCompact hook event (handled in handleClaudeHookEnvelope) is
+    // the reliable signal; this regex match serves as a best-effort fallback.
     shouldTreatClaudeOutputAsCompactCompletion(text) {
         if (this.state.status !== "busy" &&
             this.state.status !== "awaiting_approval" &&
@@ -664,6 +732,8 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.currentPreview = "(idle)";
     }
     handleClaudeHookEnvelope(params) {
+        this.hookReceivedCount++;
+        this.clearHookHealthCheck();
         const payload = parseClaudeHookPayload(params.rawPayload);
         if (!payload?.hook_event_name) {
             this.respondToClaudeHook(params.socket, params.requestId);
@@ -682,8 +752,32 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
                 this.handleClaudePermissionRequest(params.requestId, payload, params.socket);
                 return;
             case "Notification":
-                if (payload.notification_type === "permission_prompt" && this.pendingApproval) {
-                    this.setStatus("awaiting_approval", "Claude approval is required.");
+                if (payload.notification_type === "permission_prompt") {
+                    if (this.pendingApproval) {
+                        this.setStatus("awaiting_approval", "Claude approval is required.");
+                    }
+                    else if (this.lastAutoApprovedPayload) {
+                        // Auto-approval response failed to reach Claude Code (socket closed before delivery).
+                        // Fall back to forwarding the approval request to WeChat.
+                        const fallbackPayload = this.lastAutoApprovedPayload;
+                        this.lastAutoApprovedPayload = null;
+                        const request = buildClaudePermissionApprovalRequest(fallbackPayload);
+                        this.pendingApproval = {
+                            ...request,
+                            requestId: undefined,
+                            confirmInput: this.pendingCliApprovalHints?.confirmInput,
+                            denyInput: this.pendingCliApprovalHints?.denyInput,
+                        };
+                        this.pendingCliApprovalHints = null;
+                        this.state.pendingApproval = this.pendingApproval;
+                        this.state.pendingApprovalOrigin = this.state.activeTurnOrigin;
+                        this.setStatus("awaiting_approval", "Claude auto-approval failed, forwarding to WeChat.");
+                        this.emit({
+                            type: "approval_required",
+                            request: this.pendingApproval,
+                            timestamp: nowIso(),
+                        });
+                    }
                 }
                 this.respondToClaudeHook(params.socket, params.requestId);
                 return;
@@ -695,6 +789,10 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
                 this.handleClaudeStopFailure(payload);
                 this.respondToClaudeHook(params.socket, params.requestId);
                 return;
+            case "PostCompact":
+                this.completeClaudeCompact();
+                this.respondToClaudeHook(params.socket, params.requestId);
+                return;
             default:
                 this.respondToClaudeHook(params.socket, params.requestId);
                 return;
@@ -732,6 +830,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.state.resumeConversationId = nextResumeConversationId ?? undefined;
         this.transcriptPath = nextTranscriptPath;
         this.state.transcriptPath = nextTranscriptPath ?? undefined;
+        this.startTranscriptThinkingWatch();
         if (previousRuntimeSessionId === payload.session_id) {
             return;
         }
@@ -770,6 +869,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.pendingCliApprovalHints = null;
         this.clearWechatWorkingNotice(true);
         this.setStatus("busy");
+        this.startTranscriptThinkingWatch();
         this.emit({
             type: "mirrored_user_input",
             text: prompt,
@@ -809,6 +909,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     }
     handleClaudePermissionRequest(requestId, payload, socket) {
         this.clearWechatWorkingNotice();
+        this.lastAutoApprovedPayload = null;
         const denyMessage = getClaudeWechatOutboundAttachmentDenyMessage(payload);
         if (denyMessage) {
             this.pendingApproval = null;
@@ -825,6 +926,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             if (!this.pendingApproval && !this.state.pendingApproval) {
                 this.setStatus("busy", `Claude approval auto-approved: ${truncatePreview(autoResponse.reason, 180)}`);
             }
+            this.lastAutoApprovedPayload = payload;
             this.respondToClaudeHook(socket, requestId, buildClaudePermissionDecisionHookOutput(autoResponse.action));
             return;
         }
@@ -890,6 +992,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     handleClaudeStop(payload) {
         this.clearWechatWorkingNotice(true);
         this.pendingCliApprovalHints = null;
+        this.lastAutoApprovedPayload = null;
         this.flushPendingClaudeHookApprovals();
         this.pendingApproval = null;
         this.state.pendingApproval = null;
@@ -907,11 +1010,97 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             summary: this.currentPreview,
             timestamp: nowIso(),
         });
+        this.stopTranscriptThinkingWatch();
         this.currentPreview = "(idle)";
     }
     handleClaudeStopFailure(payload) {
+        this.lastAutoApprovedPayload = null;
+        this.stopTranscriptThinkingWatch();
         this.failClaudeTurn(buildClaudeFailureMessage(payload));
     }
+    startTranscriptThinkingWatch() {
+        this.stopTranscriptThinkingWatch();
+        if (!this.transcriptPath) {
+            return;
+        }
+        if (!isThinkingForwardEnabled()) {
+            return;
+        }
+        this.transcriptTailOffset = 0;
+        try {
+            const stat = fs.statSync(this.transcriptPath);
+            this.transcriptTailOffset = stat.size;
+        }
+        catch {
+            return;
+        }
+        const watchPath = this.transcriptPath;
+        const sessionId = this.runtimeSessionId;
+        this.polledTranscriptSessionId = sessionId;
+        this.transcriptPollTimer = setInterval(() => {
+            if (this.shuttingDown) {
+                this.stopTranscriptThinkingWatch();
+                return;
+            }
+            if (this.polledTranscriptSessionId !== this.runtimeSessionId) {
+                this.stopTranscriptThinkingWatch();
+                return;
+            }
+            try {
+                const stat = fs.statSync(watchPath);
+                if (stat.size <= this.transcriptTailOffset) {
+                    return;
+                }
+                const fd = fs.openSync(watchPath, "r");
+                const buf = Buffer.alloc(stat.size - this.transcriptTailOffset);
+                fs.readSync(fd, buf, 0, buf.length, this.transcriptTailOffset);
+                fs.closeSync(fd);
+                this.transcriptTailOffset = stat.size;
+                const newText = buf.toString("utf8");
+                const lines = newText.split(/\r?\n/).filter(Boolean);
+                for (const line of lines) {
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!parsed ||
+                        parsed.type !== "assistant" ||
+                        !Array.isArray(parsed.message?.content)) {
+                        continue;
+                    }
+                    for (const block of parsed.message.content) {
+                        if (block.type === "thinking" &&
+                            typeof block.thinking === "string" &&
+                            block.thinking.trim()) {
+                            const thinking = normalizeOutput(block.thinking).trim();
+                            if (thinking) {
+                                this.emit({
+                                    type: "thinking",
+                                    text: thinking,
+                                    timestamp: nowIso(),
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // File may be temporarily locked or deleted; silently retry next poll.
+            }
+        }, 800);
+        this.transcriptPollTimer.unref?.();
+    }
+    stopTranscriptThinkingWatch() {
+        if (this.transcriptPollTimer) {
+            clearInterval(this.transcriptPollTimer);
+            this.transcriptPollTimer = null;
+        }
+        this.transcriptTailOffset = 0;
+        this.polledTranscriptSessionId = null;
+    }
     respondToClaudeHook(socket, requestId, stdout) {
         try {
             socket.end(`${JSON.stringify({ requestId, stdout })}\n`);