@bastdewfn/cc-remote 1.0.9

package/dist/relay.js

@@ -0,0 +1,851 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreRelay = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const http = __importStar(require("http"));
+const core_1 = require("./core");
+class CoreRelay {
+    constructor(deps) {
+        this.server = null;
+        this.pendingApprovals = new Map();
+        this.wxPendingApprovals = new Map();
+        this.diag = {};
+        this.config = deps.config;
+        this.configPath = deps.configPath;
+        this.targetDir = deps.targetDir;
+        this.feishuReplier = deps.feishuReplier;
+        this.weixinReplier = deps.weixinReplier;
+        this.onStatus = deps.onStatus;
+    }
+    start(port) {
+        const relayPort = port ?? this.config.relayPort ?? 19200;
+        this.server = http.createServer((req, res) => this._handleRequest(req, res));
+        this.server.listen(relayPort, '127.0.0.1', () => {
+            this.onStatus(`\r\n🔗 HTTP Relay 已启动: 127.0.0.1:${relayPort}\r\n`);
+        });
+        this.server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                throw new Error(`端口 ${relayPort} 已被占用，无法启动 Relay`);
+            }
+            throw err;
+        });
+    }
+    stop() {
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+    }
+    get running() {
+        return this.server !== null;
+    }
+    // ---- Private ----
+    _log(msg) {
+        const date = new Date().toISOString().slice(0, 10).replace(/-/g, '');
+        const logFile = (0, core_1.dataPath)(this.targetDir, `relay-${date}.log`);
+        try {
+            fs.appendFileSync(logFile, `[${new Date().toISOString()}] ${msg}\n`);
+        }
+        catch { /* ignore */ }
+    }
+    _handleRequest(req, res) {
+        if (req.method === 'POST' && req.url === '/notify') {
+            this._handleNotify(req, res);
+        }
+        else if (req.method === 'POST' && req.url === '/approval-create') {
+            this._handleApprovalCreate(req, res);
+        }
+        else if (req.method === 'POST' && req.url === '/hooks/pre-tool-use') {
+            this._handlePreToolUse(req, res);
+        }
+        else if (req.method === 'POST' && req.url === '/hooks/stop-notify') {
+            this._handleStopNotify(req, res);
+        }
+        else if (req.method === 'POST' && req.url === '/feishu-mode') {
+            this._handleFeishuMode(req, res);
+        }
+        else if (req.method === 'GET' && req.url === '/doctor') {
+            this._handleDoctor(req, res);
+        }
+        else {
+            res.writeHead(404);
+            res.end();
+        }
+    }
+    // ---- /notify ----
+    _handleNotify(req, res) {
+        let body = '';
+        req.on('data', (chunk) => { body += chunk; });
+        req.on('end', async () => {
+            this._log('POST /notify body=' + body);
+            try {
+                const payload = JSON.parse(body);
+                const { chatId } = payload;
+                this._log(`chatId=${chatId}, type=${payload.type || 'text'}`);
+                if (!chatId) {
+                    this._log('400 missing chatId');
+                    res.writeHead(400);
+                    res.end(JSON.stringify({ ok: false, error: 'missing chatId' }));
+                    return;
+                }
+                if (payload.type === 'post' && payload.title && payload.paragraphs) {
+                    await this.feishuReplier.sendPost(chatId, payload.title, payload.paragraphs);
+                    this._log('sendPost OK');
+                }
+                else if (payload.type === 'card' && payload.card) {
+                    await this.feishuReplier.sendCard(chatId, payload.card);
+                    this._log('sendCard OK');
+                }
+                else if (payload.text) {
+                    await this.feishuReplier.sendText(chatId, payload.text);
+                    this._log('sendText OK');
+                }
+                else {
+                    this._log('400 no valid content');
+                    res.writeHead(400);
+                    res.end(JSON.stringify({ ok: false, error: 'no valid content' }));
+                    return;
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true }));
+            }
+            catch (err) {
+                this._log('500 error: ' + (err instanceof Error ? err.message : String(err)));
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: String(err) }));
+            }
+        });
+    }
+    // ---- /approval-create ----
+    _handleApprovalCreate(req, res) {
+        let body = '';
+        req.on('data', (chunk) => { body += chunk; });
+        req.on('end', async () => {
+            this._log('POST /approval-create body=' + body);
+            try {
+                const { chatId, requestId, toolName, toolInput } = JSON.parse(body);
+                if (this.config.enableFeishu === false) {
+                    this._log('approval-create: feishu disabled, skip');
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true, skipped: true }));
+                    return;
+                }
+                if (chatId && requestId && toolName) {
+                    const safeId = requestId.replace(/[^a-zA-Z0-9_-]/g, '_');
+                    const card = (0, core_1.buildApprovalCard)(toolName, toolInput, safeId);
+                    await this.feishuReplier.sendCard(chatId, card);
+                    this._log('approval card sent for ' + toolName);
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true }));
+            }
+            catch (err) {
+                this._log('approval-create error: ' + (err instanceof Error ? err.message : String(err)));
+                res.writeHead(500);
+                res.end(JSON.stringify({ ok: false }));
+            }
+        });
+    }
+    // ---- /hooks/pre-tool-use ----
+    _handlePreToolUse(req, res) {
+        req.socket.setTimeout(0);
+        let body = '';
+        req.on('data', (chunk) => { body += chunk; });
+        req.on('end', async () => {
+            this._log('POST /hooks/pre-tool-use body=' + body);
+            try {
+                const hookInput = JSON.parse(body);
+                const toolName = hookInput.tool_name || '';
+                const toolInput = hookInput.tool_input || {};
+                const permissionMode = hookInput.permission_mode || 'default';
+                const projectDir = hookInput.project || this.targetDir;
+                const contextPath = (0, core_1.dataPathFor)(projectDir, 'cc_remote_context.json');
+                let ctx = {};
+                if (fs.existsSync(contextPath)) {
+                    try {
+                        ctx = JSON.parse(fs.readFileSync(contextPath, 'utf-8'));
+                    }
+                    catch { /* ignore */ }
+                }
+                // close mode → empty response → Claude falls back to native
+                if (ctx.mode !== 'remote') {
+                    this._log('pre-tool-use: mode not remote, skip');
+                    res.writeHead(204);
+                    res.end();
+                    return;
+                }
+                if (permissionMode === 'bypassPermissions') {
+                    this._log(`pre-tool-use: bypassPermissions, allow ${toolName}`);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow', permissionDecisionReason: 'bypassPermissions mode' },
+                    }));
+                    return;
+                }
+                const allowPatterns = (0, core_1.loadAllowPatterns)(projectDir);
+                for (const pattern of allowPatterns) {
+                    if ((0, core_1.matchesPermission)(toolName, toolInput, pattern)) {
+                        this._log(`pre-tool-use: matched "${pattern}", allow ${toolName}`);
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({
+                            hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow', permissionDecisionReason: `匹配权限规则: ${pattern}` },
+                        }));
+                        return;
+                    }
+                }
+                // Safe tools: auto-allow without approval
+                if ((0, core_1.isSafeTool)(toolName)) {
+                    this._log(`pre-tool-use: safe tool ${toolName}, auto-allow`);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow', permissionDecisionReason: `安全工具自动放行` },
+                    }));
+                    if (toolName === 'AskUserQuestion') {
+                        const channel = ctx.channel || 'feishu';
+                        if (channel === 'weixin') {
+                            const wxUserId = ctx.userId || '';
+                            if (wxUserId) {
+                                await this.weixinReplier?.sendText(wxUserId, (0, core_1.formatAskUserQuestion)(toolInput), ctx.contextToken);
+                            }
+                        }
+                        else {
+                            const chatId = ctx.chatId || '';
+                            if (chatId) {
+                                const card = (0, core_1.buildAskUserQuestionCard)(toolInput);
+                                await this.feishuReplier.sendCard(chatId, card);
+                            }
+                        }
+                    }
+                    if (toolName === 'ExitPlanMode') {
+                        const channel = ctx.channel || 'feishu';
+                        if (channel === 'weixin') {
+                            const wxUserId = ctx.userId || '';
+                            if (wxUserId) {
+                                await this.weixinReplier?.sendText(wxUserId, (0, core_1.formatExitPlanMode)(toolInput), ctx.contextToken);
+                            }
+                        }
+                        else {
+                            const chatId = ctx.chatId || '';
+                            if (chatId) {
+                                const card = (0, core_1.buildExitPlanModeCard)(toolInput);
+                                await this.feishuReplier.sendCard(chatId, card);
+                            }
+                        }
+                    }
+                    return;
+                }
+                const channel = ctx.channel || 'feishu';
+                let decision;
+                // ---- WeChat text-based approval ----
+                if (channel === 'weixin') {
+                    const wxUserId = ctx.userId || '';
+                    if (!wxUserId) {
+                        this._log('pre-tool-use: no weixin userId, deny');
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({
+                            hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: '无微信会话上下文' },
+                        }));
+                        return;
+                    }
+                    const approvalText = `🟢 工具审批: ${toolName}\n${JSON.stringify(toolInput, null, 2)}\n\n回复 go=允许 / no=拒绝 / ok=始终允许`;
+                    await this.weixinReplier?.sendText(wxUserId, approvalText, ctx.contextToken);
+                    this._log(`weixin approval text sent for ${toolName}, userId=${wxUserId}`);
+                    const timeoutMs = (this.config.approvalTimeoutS || 1800) * 1000;
+                    decision = await new Promise((resolve) => {
+                        const timer = setTimeout(() => {
+                            this.wxPendingApprovals.delete(wxUserId);
+                            this._log(`weixin approval timeout for ${toolName}`);
+                            resolve('deny');
+                        }, timeoutMs);
+                        this.wxPendingApprovals.set(wxUserId, { userId: wxUserId, toolName, resolve, timer });
+                    });
+                }
+                else {
+                    // ---- Feishu card-based approval ----
+                    const chatId = ctx.chatId || '';
+                    if (!chatId) {
+                        this._log('pre-tool-use: no chatId, deny');
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({
+                            hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: '无飞书会话上下文' },
+                        }));
+                        return;
+                    }
+                    const rawId = `${chatId}:${toolName}:${Date.now()}`;
+                    const requestId = rawId.replace(/[^a-zA-Z0-9_-]/g, '_');
+                    const card = (0, core_1.buildApprovalCard)(toolName, JSON.stringify(toolInput, null, 2), requestId);
+                    await this.feishuReplier.sendCard(chatId, card);
+                    this._log(`approval card sent for ${toolName}, requestId=${requestId}`);
+                    const timeoutMs = (this.config.approvalTimeoutS || 1800) * 1000;
+                    decision = await new Promise((resolve) => {
+                        const timer = setTimeout(() => {
+                            this.pendingApprovals.delete(requestId);
+                            this._log(`approval timeout for ${toolName}`);
+                            resolve('deny');
+                        }, timeoutMs);
+                        this.pendingApprovals.set(requestId, { resolve, timer, projectDir });
+                    });
+                }
+                // Handle always_allow for WeChat (Feishu does it in handleCardAction)
+                if (decision === 'always_allow' && channel === 'weixin') {
+                    const localSettingsPath = path.join(projectDir, '.claude', 'settings.local.json');
+                    try {
+                        let settings = { permissions: { allow: [] } };
+                        if (fs.existsSync(localSettingsPath)) {
+                            settings = JSON.parse(fs.readFileSync(localSettingsPath, 'utf-8'));
+                        }
+                        if (!settings.permissions)
+                            settings.permissions = {};
+                        if (!Array.isArray(settings.permissions.allow))
+                            settings.permissions.allow = [];
+                        if (!settings.permissions.allow.includes(toolName)) {
+                            settings.permissions.allow.push(toolName);
+                            fs.writeFileSync(localSettingsPath, JSON.stringify(settings, null, 2));
+                            this._log(`added "${toolName}" to permissions.allow`);
+                        }
+                    }
+                    catch (e) {
+                        this._log(`failed to update settings: ${e}`);
+                    }
+                }
+                const resDecision = (decision === 'deny') ? 'deny' : 'allow';
+                const resReason = decision === 'always_allow' ? '用户始终允许' : decision === 'allow' ? '用户允许' : '用户拒绝';
+                this._log(`pre-tool-use done: ${toolName} -> ${resDecision} (${resReason})`);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: resDecision, permissionDecisionReason: resReason },
+                }));
+            }
+            catch (err) {
+                this._log('pre-tool-use error: ' + (err instanceof Error ? err.message : String(err)));
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: '审批处理异常' },
+                }));
+            }
+        });
+    }
+    // ---- /hooks/stop-notify ----
+    _handleStopNotify(req, res) {
+        let body = '';
+        req.on('data', (chunk) => { body += chunk; });
+        req.on('end', async () => {
+            this._log('POST /hooks/stop-notify body=' + body);
+            try {
+                const hookInput = JSON.parse(body);
+                const projectDir = hookInput.project || this.targetDir;
+                const contextPath = (0, core_1.dataPathFor)(projectDir, 'cc_remote_context.json');
+                let context = {};
+                if (fs.existsSync(contextPath)) {
+                    try {
+                        context = JSON.parse(fs.readFileSync(contextPath, 'utf-8'));
+                    }
+                    catch { /* ignore */ }
+                }
+                if (context.mode !== 'remote') {
+                    this._log('stop-notify: mode not remote, skip');
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true, skipped: true }));
+                    return;
+                }
+                const channel = context.channel || 'feishu';
+                const chatId = context.chatId;
+                const wxUserId = context.userId;
+                const wxContextToken = context.contextToken;
+                if (channel === 'weixin') {
+                    if (!wxUserId) {
+                        this._log('stop-notify: no weixin userId');
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: true, skipped: true }));
+                        return;
+                    }
+                }
+                else {
+                    if (!chatId) {
+                        this._log('stop-notify: no chatId');
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: true, skipped: true }));
+                        return;
+                    }
+                }
+                // Parse transcript
+                const allMessages = [];
+                if (hookInput.transcript_path && fs.existsSync(hookInput.transcript_path)) {
+                    try {
+                        const raw = fs.readFileSync(hookInput.transcript_path, 'utf-8');
+                        const lines = raw.split('\n');
+                        for (const line of lines) {
+                            const trimmed = line.trim();
+                            if (!trimmed)
+                                continue;
+                            try {
+                                allMessages.push(JSON.parse(trimmed));
+                            }
+                            catch { /* skip */ }
+                        }
+                    }
+                    catch { /* ignore */ }
+                }
+                // Extract last assistant text
+                let replyText = '';
+                for (let i = allMessages.length - 1; i >= 0; i--) {
+                    const msg = allMessages[i];
+                    if (msg.role === 'assistant' || msg.type === 'assistant') {
+                        const content = msg.content || msg.message?.content;
+                        if (Array.isArray(content)) {
+                            const parts = [];
+                            for (const block of content) {
+                                if (block.type === 'text' && typeof block.text === 'string')
+                                    parts.push(block.text);
+                            }
+                            replyText = parts.join('\n');
+                        }
+                        else if (typeof content === 'string') {
+                            replyText = content;
+                        }
+                        if (replyText)
+                            break;
+                    }
+                }
+                // Find last user message boundary
+                let scanFrom = 0;
+                for (let i = allMessages.length - 1; i >= 0; i--) {
+                    const msg = allMessages[i];
+                    if (msg.type === 'user' || msg.role === 'user') {
+                        const blocks = msg.message?.content;
+                        if (Array.isArray(blocks)) {
+                            const hasText = blocks.some((b) => b.type === 'text' && typeof b.text === 'string' && b.text.trim());
+                            if (hasText) {
+                                scanFrom = i;
+                                break;
+                            }
+                        }
+                        else if (typeof msg.message?.content === 'string' && msg.message.content.trim()) {
+                            scanFrom = i;
+                            break;
+                        }
+                    }
+                }
+                const toolCalls = [];
+                for (let idx = scanFrom; idx < allMessages.length; idx++) {
+                    const msg = allMessages[idx];
+                    if (msg.type === 'assistant') {
+                        const blocks = msg.message?.content ?? [];
+                        for (const b of blocks) {
+                            if (b.type === 'tool_use' && typeof b.name === 'string') {
+                                toolCalls.push({ name: b.name, ok: true, input: b.input ?? {} });
+                            }
+                        }
+                    }
+                    if (msg.type === 'user') {
+                        const blocks = msg.message?.content ?? [];
+                        for (const b of blocks) {
+                            if (b.type === 'tool_result') {
+                                for (let j = 0; j < toolCalls.length; j++) {
+                                    if (!toolCalls[j].matched) {
+                                        if (b.is_error)
+                                            toolCalls[j].ok = false;
+                                        const content = b.content;
+                                        if (typeof content === 'string') {
+                                            toolCalls[j].output = content;
+                                        }
+                                        else if (Array.isArray(content)) {
+                                            const parts = [];
+                                            for (const c of content) {
+                                                if (c.type === 'text' && typeof c.text === 'string')
+                                                    parts.push(c.text);
+                                                else if (typeof c.text === 'string')
+                                                    parts.push(c.text);
+                                            }
+                                            toolCalls[j].output = parts.join('\n');
+                                        }
+                                        const tur = msg.toolUseResult;
+                                        if (tur && typeof tur === 'object') {
+                                            if (toolCalls[j].name === 'Edit' || toolCalls[j].name === 'Write') {
+                                                const oldS = String(tur.oldString ?? '');
+                                                const newS = String(tur.newString ?? '');
+                                                if (oldS || newS)
+                                                    toolCalls[j].output = oldS + '\n' + newS;
+                                            }
+                                            else if (toolCalls[j].output === undefined && typeof tur.stdout === 'string') {
+                                                toolCalls[j].output = tur.stdout;
+                                            }
+                                        }
+                                        toolCalls[j].matched = true;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                // Extract usage
+                let usage = null;
+                let durationMs = 0;
+                for (let i = allMessages.length - 1; i >= 0; i--) {
+                    if (allMessages[i].type === 'result') {
+                        usage = allMessages[i].usage;
+                        durationMs = allMessages[i].duration_ms ?? 0;
+                        break;
+                    }
+                }
+                if (!replyText && toolCalls.length === 0) {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true, skipped: true }));
+                    return;
+                }
+                let sent = false;
+                if (channel === 'weixin') {
+                    const text = replyText.trim() || 'Claude 回复';
+                    const msgId = await this.weixinReplier?.sendText(wxUserId, text, wxContextToken);
+                    sent = !!msgId;
+                    this._log(`stop-notify weixin ${sent ? 'sent OK' : 'FAILED'}`);
+                }
+                else {
+                    let payload;
+                    if (toolCalls.length > 0) {
+                        const elements = [];
+                        if (replyText) {
+                            elements.push({ tag: 'markdown', content: replyText });
+                            elements.push({ tag: 'hr' });
+                        }
+                        for (const t of toolCalls) {
+                            if (t.name === 'Read' || t.name === 'Grep' || t.name === 'Glob')
+                                continue;
+                            const status = t.ok ? '✓' : '✗';
+                            const parts = [];
+                            const inp = t.input;
+                            if (inp.file_path)
+                                parts.push(`📄 ${String(inp.file_path)}`);
+                            else if (inp.command)
+                                parts.push(`💻 ${String(inp.command)}`);
+                            else if (inp.url)
+                                parts.push(`🔗 ${String(inp.url)}`);
+                            else if (inp.pattern)
+                                parts.push(`🔍 ${String(inp.pattern)}`);
+                            else if (inp.query)
+                                parts.push(`🔍 ${String(inp.query)}`);
+                            if (t.output)
+                                parts.push(`\`\`\`\n${t.output}\n\`\`\``);
+                            elements.push({ tag: 'markdown', content: `🔧 **${t.name}** ${status}\n${parts.join('\n')}` });
+                            elements.push({ tag: 'hr' });
+                        }
+                        if (usage) {
+                            const dur = durationMs ? `${(durationMs / 1000).toFixed(1)}s` : 'N/A';
+                            elements.push({ tag: 'markdown', content: `📊 Token: 输入 ${(0, core_1.fmtK)(usage.input_tokens)} | 输出 ${(0, core_1.fmtK)(usage.output_tokens)} | 缓存读 ${(0, core_1.fmtK)(usage.cache_read_input_tokens)} | 耗时 ${dur}` });
+                        }
+                        payload = {
+                            chatId,
+                            type: 'card',
+                            card: {
+                                schema: '2.0',
+                                config: { wide_screen_mode: true },
+                                header: { title: { tag: 'plain_text', content: 'Claude 执行完成' }, template: 'green' },
+                                body: { elements },
+                            },
+                        };
+                    }
+                    else {
+                        payload = { chatId, type: 'text', text: replyText.trim() || 'Claude 回复' };
+                    }
+                    if (payload.type === 'text') {
+                        const msgId = await this.feishuReplier.sendText(payload.chatId, payload.text);
+                        sent = !!msgId;
+                    }
+                    else {
+                        const msgId = await this.feishuReplier.sendCard(payload.chatId, payload.card);
+                        sent = !!msgId;
+                    }
+                    this._log(`stop-notify feishu ${sent ? 'sent OK' : 'FAILED'}`);
+                }
+                // Cleanup: preserve mode, channel, user ids, clear messageId
+                try {
+                    const preserved = { mode: context.mode, channel };
+                    if (channel === 'weixin') {
+                        if (context.userId)
+                            preserved.userId = context.userId;
+                        if (context.contextToken)
+                            preserved.contextToken = context.contextToken;
+                    }
+                    else {
+                        if (context.chatId)
+                            preserved.chatId = context.chatId;
+                        if (context.openId)
+                            preserved.openId = context.openId;
+                    }
+                    fs.writeFileSync(contextPath, JSON.stringify(preserved));
+                }
+                catch { /* ignore */ }
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true }));
+            }
+            catch (err) {
+                this._log('stop-notify error: ' + (err instanceof Error ? err.message : String(err)));
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: String(err) }));
+            }
+        });
+    }
+    // ---- /feishu-mode ----
+    _handleFeishuMode(req, res) {
+        let body = '';
+        req.on('data', (chunk) => { body += chunk; });
+        req.on('end', () => {
+            this._log('POST /feishu-mode body=' + body);
+            try {
+                const { mode, project } = JSON.parse(body);
+                if (mode !== 'remote' && mode !== 'close') {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'mode must be remote or close' }));
+                    return;
+                }
+                const contextPath = (0, core_1.dataPathFor)(project || this.targetDir, 'cc_remote_context.json');
+                let ctx = {};
+                if (fs.existsSync(contextPath)) {
+                    try {
+                        ctx = JSON.parse(fs.readFileSync(contextPath, 'utf-8'));
+                    }
+                    catch { /* ignore */ }
+                }
+                ctx.mode = mode;
+                fs.writeFileSync(contextPath, JSON.stringify(ctx));
+                const channelLabel = ctx.channel === 'weixin' ? '微信' : '飞书';
+                const label = mode === 'remote' ? `🔗 ${channelLabel}远程模式已启用` : `🔌 ${channelLabel}远程模式已关闭`;
+                this._log('feishu-mode: ' + label);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, mode, message: label }));
+            }
+            catch (err) {
+                this._log('feishu-mode error: ' + (err instanceof Error ? err.message : String(err)));
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: String(err) }));
+            }
+        });
+    }
+    // ---- /doctor ----
+    async _handleDoctor(_req, res) {
+        const contextPath = (0, core_1.dataPath)(this.targetDir, 'cc_remote_context.json');
+        const settingsLocalPath = path.join(this.targetDir, '.claude', 'settings.local.json');
+        let settings = {};
+        try {
+            settings = JSON.parse(fs.readFileSync(settingsLocalPath, 'utf-8'));
+        }
+        catch { /* ignore */ }
+        let configOk = false;
+        let configFields = [];
+        try {
+            const c = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+            configOk = !!(c.appId && c.appSecret);
+            configFields = Object.keys(c).filter(k => c[k]);
+        }
+        catch { /* ignore */ }
+        const pt = settings?.hooks?.PreToolUse;
+        const st = settings?.hooks?.Stop;
+        const hooksPreToolUse = Array.isArray(pt) && pt.some((e) => (e.matcher || '') === '' && Array.isArray(e.hooks) && e.hooks.length > 0);
+        const hooksStop = Array.isArray(st) && st.some((e) => (e.matcher || '') === '' && Array.isArray(e.hooks) && e.hooks.length > 0);
+        const hookCommands = {
+            preToolUse: Array.isArray(pt) ? pt.flatMap((e) => (e.hooks || []).map((h) => h.command || '').filter(Boolean)) : [],
+            stop: Array.isArray(st) ? st.flatMap((e) => (e.hooks || []).map((h) => h.command || '').filter(Boolean)) : [],
+        };
+        const permissionsAllow = settings?.permissions?.allow || [];
+        const hasCcRemote = permissionsAllow.some((r) => r.includes('cc-remote'));
+        let contextMode = 'unknown';
+        let contextChatId = '';
+        try {
+            const ctx = JSON.parse(fs.readFileSync(contextPath, 'utf-8'));
+            contextMode = ctx.mode || 'close';
+            contextChatId = ctx.chatId || '';
+        }
+        catch { /* ignore */ }
+        // Feishu API test
+        let apiOk = false;
+        let apiError = '';
+        try {
+            const { createFeishuClient } = require('./feishu/client');
+            const testClient = createFeishuClient({ appId: this.config.appId, appSecret: this.config.appSecret });
+            await testClient.im.v1.chat.list({ params: { page_size: 1 } });
+            apiOk = true;
+        }
+        catch (e) {
+            const msg = String(e.message || e);
+            if (msg.includes('auth') || msg.includes('AppNotFound') || msg.includes('app_id')) {
+                apiError = '认证失败: appId/appSecret 无效';
+            }
+            else {
+                apiError = msg.slice(0, 200);
+                apiOk = true;
+            }
+        }
+        const d = this.diag;
+        const relayPort = this.config.relayPort || 19200;
+        const report = {
+            time: new Date().toISOString(),
+            config: { ok: configOk, path: this.configPath, fields: configFields, hint: configOk ? 'OK' : 'config.json 缺少 appId 或 appSecret' },
+            hooks: { preToolUse: hooksPreToolUse, stop: hooksStop, hookCommands, hint: (hooksPreToolUse && hooksStop) ? 'OK' : 'Hook 未配置，飞书 remote 模式下审批和通知不会工作' },
+            permissions: { allow: permissionsAllow, hasCcRemote, hint: hasCcRemote ? 'OK' : '缺少 cc-remote 权限规则，hook 可能无法执行' },
+            connection: {
+                wsConnected: d.wsConnected,
+                wsConnectTime: d.wsConnectTime ? new Date(d.wsConnectTime).toISOString() : null,
+                wsUptimeSec: d.wsConnectTime ? Math.floor((Date.now() - d.wsConnectTime) / 1000) : 0,
+                relayRunning: this.running,
+                hint: d.wsConnected ? 'OK' : 'WebSocket 未连接，检查网络和飞书后台配置',
+            },
+            relay: { port: relayPort, running: this.running, hint: this.running ? `OK (127.0.0.1:${relayPort})` : '未运行' },
+            pty: { pid: d.ptyPid || null, alive: d.ptyAlive || false, hint: d.ptyPid ? `运行中 PID=${d.ptyPid}` : '未启动' },
+            weixin: {
+                enabled: d.weixinEnabled || false,
+                clientStarted: d.weixinClientStarted || false,
+                accountId: d.weixinAccountId || null,
+                hint: d.weixinClientStarted ? 'OK' : (d.weixinEnabled ? '客户端未启动' : '未启用'),
+            },
+            messages: {
+                lastReceiveTime: d.lastMessageTime ? new Date(d.lastMessageTime).toISOString() : null,
+                lastReceiveText: (d.lastMessageText || '').slice(0, 200),
+                lastSendError: d.lastSendError || null,
+                pendingApprovals: this.pendingApprovals.size,
+                hint: d.lastMessageTime ? 'OK' : '从未收到飞书消息，检查机器人是否上线、事件是否订阅',
+            },
+            api: { ok: apiOk, error: apiError || null, hint: apiOk ? 'OK' : `飞书 API 不通: ${apiError}` },
+            context: { mode: contextMode, chatId: contextChatId || '(空)', hint: contextMode === 'remote' ? '当前为 remote 模式' : '当前为 close 模式（飞书消息仅转发到终端，不触发 hook 审批）' },
+        };
+        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify(report, null, 2));
+    }
+    // ---- handleCardAction (consolidated from main.ts handleCardAction + dead card-action.ts) ----
+    async handleCardAction(raw) {
+        const log = (msg) => {
+            const date = new Date().toISOString().slice(0, 10).replace(/-/g, '');
+            try {
+                fs.appendFileSync((0, core_1.dataPath)(this.targetDir, `card-action-${date}.log`), `[${new Date().toISOString()}] ${msg}\n`);
+            }
+            catch { /* ignore */ }
+        };
+        try {
+            log(`raw: ${JSON.stringify(raw)}`);
+            const data = raw;
+            const event = (data['event'] ?? data);
+            log(`event keys: ${Object.keys(event).join(', ')}`);
+            const messageId = (event['open_message_id'] ?? event['context']?.['open_message_id'] ?? '');
+            log(`messageId: ${messageId}`);
+            const actionObj = (event['action'] ?? {});
+            log(`actionObj keys: ${Object.keys(actionObj).join(', ')}, value: ${String(actionObj['value']).slice(0, 200)}`);
+            const rawValue = actionObj['value'];
+            if (!rawValue) {
+                log('BAIL: no value');
+                return {};
+            }
+            let value;
+            if (typeof rawValue === 'string') {
+                value = JSON.parse(rawValue);
+                if (typeof value === 'string') {
+                    log(`double-encoded value, parsing again`);
+                    value = JSON.parse(value);
+                }
+            }
+            else if (typeof rawValue === 'object') {
+                value = rawValue;
+            }
+            else {
+                log(`BAIL: unexpected value type: ${typeof rawValue}`);
+                return {};
+            }
+            log(`parsed value: cmd=${value.cmd}, requestId=${value.requestId}, decision=${value.decision}, toolName=${value.toolName}`);
+            if (value.cmd !== '__approve') {
+                log(`BAIL: cmd=${value.cmd} != __approve`);
+                return {};
+            }
+            const requestId = value.requestId;
+            const rawDecision = value.decision;
+            const toolName = value.toolName || '';
+            const resDecision = (rawDecision === 'deny') ? 'deny' : 'allow';
+            const pending = this.pendingApprovals.get(requestId);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.pendingApprovals.delete(requestId);
+                log(`resolving pending approval: ${requestId} -> ${resDecision}`);
+                pending.resolve(resDecision);
+            }
+            const projDir = pending?.projectDir || this.targetDir;
+            const resPath = (0, core_1.dataPathFor)(projDir, `approval_res_${requestId}.json`);
+            if (rawDecision === 'always_allow') {
+                const localSettingsPath = path.join(projDir, '.claude', 'settings.local.json');
+                try {
+                    let settings = { permissions: { allow: [] } };
+                    if (fs.existsSync(localSettingsPath)) {
+                        settings = JSON.parse(fs.readFileSync(localSettingsPath, 'utf-8'));
+                    }
+                    if (!settings.permissions)
+                        settings.permissions = {};
+                    if (!Array.isArray(settings.permissions.allow))
+                        settings.permissions.allow = [];
+                    if (!settings.permissions.allow.includes(toolName)) {
+                        settings.permissions.allow.push(toolName);
+                        fs.writeFileSync(localSettingsPath, JSON.stringify(settings, null, 2));
+                        log(`added "${toolName}" to permissions.allow in settings.local.json`);
+                    }
+                }
+                catch (e) {
+                    log(`failed to update settings: ${e}`);
+                }
+            }
+            log(`writing res file: ${resPath} -> decision=${resDecision}`);
+            fs.writeFileSync(resPath, JSON.stringify({ decision: resDecision }));
+            log(`res file written, exists: ${fs.existsSync(resPath)}`);
+            if (messageId && toolName) {
+                log(`patching card: messageId=${messageId}, toolName=${toolName}`);
+                this.feishuReplier.patchCard(messageId, (0, core_1.buildResolvedApprovalCard)(toolName, rawDecision))
+                    .then(() => log('patchCard OK'))
+                    .catch((e) => log(`patchCard FAIL: ${e}`));
+            }
+            else {
+                log(`skip patchCard: messageId=${messageId}, toolName=${toolName}`);
+            }
+            const toast = rawDecision === 'deny'
+                ? { type: 'warning', content: '❌ 已拒绝' }
+                : rawDecision === 'always_allow'
+                    ? { type: 'success', content: '🟢 已始终允许并记住' }
+                    : { type: 'success', content: '✅ 已允许' };
+            log(`returning toast: ${toast.content}`);
+            return { toast };
+        }
+        catch (err) {
+            log(`EXCEPTION: ${err}`);
+            return { toast: { type: 'error', content: '审批处理失败' } };
+        }
+    }
+}
+exports.CoreRelay = CoreRelay;