@wu529778790/open-im 1.0.2-beta.2 → 1.0.2

package/dist/feishu/event-handler.js

@@ -2,14 +2,17 @@ import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { AccessControl } from '../access/access-control.js';
 import { RequestQueue } from '../queue/request-queue.js';
-import { sendThinkingMessage, updateMessage, sendFinalMessages, sendTextReply, startTypingLoop, sendImageReply, } from './message-sender.js';
-import { registerPermissionSender } from '../hook/permission-server.js';
+import { sendThinkingMessage, updateMessage, sendFinalMessages, sendTextReply, sendTextReplyByOpenId, startTypingLoop, sendImageReply, createFeishuButtonCard, sendModeCard, createFeishuModeCardReadOnly, delayUpdateCard, } from './message-sender.js';
+import { registerPermissionSender, resolvePermissionById } from '../hook/permission-server.js';
+import { setPermissionMode } from '../permission-mode/session-mode.js';
+import { MODE_LABELS } from '../permission-mode/types.js';
 import { CommandHandler } from '../commands/handler.js';
 import { getAdapter } from '../adapters/registry.js';
 import { runAITask } from '../shared/ai-task.js';
 import { startTaskCleanup } from '../shared/task-cleanup.js';
 import { THROTTLE_MS, IMAGE_DIR } from '../constants.js';
 import { setActiveChatId } from '../shared/active-chats.js';
+import { setChatUser } from '../shared/chat-user-map.js';
 import { createLogger } from '../logger.js';
 const log = createLogger('FeishuHandler');
 async function downloadFeishuImage(client, imageKey) {
@@ -56,6 +59,48 @@ async function downloadFeishuImage(client, imageKey) {
     await writeFile(imagePath, buffer);
     return imagePath;
 }
+/**
+ * Send permission prompt card with interactive buttons
+ */
+async function sendPermissionCard(chatId, requestId, toolName, toolInput) {
+    const { getClient } = await import('./client.js');
+    const client = getClient();
+    // Format tool input for display
+    let formattedInput;
+    if (toolInput.length > 300) {
+        formattedInput = toolInput.slice(0, 300) + '...';
+    }
+    else {
+        formattedInput = toolInput;
+    }
+    const content = `**工具:** \`${toolName}\`
+
+**参数:**
+\`\`\`
+${formattedInput}
+\`\`\`
+
+**请求 ID:** \`${requestId.slice(-8)}\``;
+    const cardContent = createFeishuButtonCard('权限请求', content, [
+        { label: '✅ 允许', value: `allow_${requestId}`, type: 'primary' },
+        { label: '❌ 拒绝', value: `deny_${requestId}`, type: 'default' },
+    ]);
+    try {
+        await client.im.message.create({
+            data: {
+                receive_id: chatId,
+                msg_type: 'interactive',
+                content: cardContent,
+            },
+            params: { receive_id_type: 'chat_id' },
+        });
+        log.info(`Permission card sent for request ${requestId}`);
+    }
+    catch (err) {
+        log.error('Failed to send permission card:', err);
+        throw err;
+    }
+}
 export function setupFeishuHandlers(config, sessionManager) {
     const accessControl = new AccessControl(config.feishuAllowedUserIds);
     const requestQueue = new RequestQueue();
@@ -65,10 +110,10 @@ export function setupFeishuHandlers(config, sessionManager) {
         config,
         sessionManager,
         requestQueue,
-        sender: { sendTextReply },
+        sender: { sendTextReply, sendModeCard },
         getRunningTasksSize: () => runningTasks.size,
     });
-    registerPermissionSender('feishu', {});
+    registerPermissionSender('feishu', { sendTextReply, sendPermissionCard });
     async function handleAIRequest(userId, chatId, prompt, workDir, convId, _threadCtx, replyToMessageId) {
         log.info(`[AI_REQUEST] userId=${userId}, chatId=${chatId}, promptLength=${prompt.length}`);
         log.info(`[AI_REQUEST] Full prompt: "${prompt}"`);
@@ -120,26 +165,183 @@ export function setupFeishuHandlers(config, sessionManager) {
             sendImage: (path) => sendImageReply(chatId, path),
         });
     }
+    /**
+     * Parse permission button value from card action (兼容多种格式)
+     */
+    function parsePermissionActionValue(raw) {
+        if (!raw)
+            return null;
+        let buttonValue;
+        if (typeof raw === 'string') {
+            try {
+                const parsed = JSON.parse(raw);
+                if (parsed.action === 'permission' && parsed.value)
+                    buttonValue = parsed.value;
+                else if (raw.startsWith('allow_') || raw.startsWith('deny_'))
+                    buttonValue = raw;
+            }
+            catch {
+                if (raw.startsWith('allow_') || raw.startsWith('deny_'))
+                    buttonValue = raw;
+            }
+        }
+        else if (typeof raw === 'object' && raw !== null) {
+            const obj = raw;
+            if (obj.action === 'permission' && obj.value)
+                buttonValue = obj.value;
+        }
+        if (!buttonValue)
+            return null;
+        if (buttonValue.startsWith('allow_')) {
+            return { decision: 'allow', requestId: buttonValue.slice(6) };
+        }
+        if (buttonValue.startsWith('deny_')) {
+            return { decision: 'deny', requestId: buttonValue.slice(5) };
+        }
+        return null;
+    }
+    /**
+     * 解析 action value（兼容对象、JSON 字符串）
+     */
+    function parseActionValue(raw) {
+        if (!raw)
+            return null;
+        let obj = null;
+        if (typeof raw === 'string') {
+            try {
+                obj = JSON.parse(raw);
+            }
+            catch {
+                return null;
+            }
+        }
+        else if (typeof raw === 'object' && raw !== null) {
+            obj = raw;
+        }
+        return obj?.action && obj?.value ? obj : null;
+    }
+    /**
+     * 从卡片回调事件中提取延时更新 token（格式 c-xxxx）
+     * 飞书文档：从卡片交互返回内容获取，用于延时更新接口
+     */
+    function extractCardToken(data) {
+        const raw = data;
+        const event = (raw?.event ?? raw);
+        const action = event?.action;
+        const context = event?.context;
+        const candidates = [
+            event?.token,
+            event?.open_api_token,
+            raw?.token,
+            action?.token,
+            context?.token,
+        ].filter((t) => typeof t === 'string' && t.startsWith('c-'));
+        const token = candidates[0] ?? null;
+        if (!token) {
+            log.debug('[extractCardToken] No token found, event keys:', Object.keys(event ?? {}));
+        }
+        return token;
+    }
+    /**
+     * Handle card button click (card.action.trigger) - 需在 3 秒内返回响应
+     * 同步只返回 toast，避免 200672；用延时更新 API 异步替换为只读卡片，防止二次点击
+     */
+    async function handleCardAction(data) {
+        // 兼容 SDK 可能嵌套的 event 结构
+        const wrapped = data;
+        const event = (wrapped?.event ?? data);
+        const actionValue = event?.action?.value;
+        const chatId = event?.context?.open_chat_id ?? event?.context?.chat_id ?? event?.context?.open_id ?? '';
+        const userId = event?.sender?.sender_id?.open_id ?? '';
+        log.info(`[handleCardAction] chatId=${chatId}, userId=${userId}, actionValue=${JSON.stringify(actionValue)}`);
+        // 处理 mode 按钮（兼容 value 为对象或 JSON 字符串）
+        const modeAv = parseActionValue(actionValue);
+        if (modeAv?.action === 'mode' && modeAv.value) {
+            const mode = modeAv.value;
+            if (['ask', 'accept-edits', 'plan', 'yolo'].includes(mode)) {
+                setPermissionMode(userId, mode);
+                const toastContent = `✅ 已切换为 ${MODE_LABELS[mode]}`;
+                const label = MODE_LABELS[mode];
+                // 异步发送文本回复，不阻塞 3 秒内返回
+                const sendReply = () => {
+                    if (chatId)
+                        return sendTextReply(chatId, toastContent);
+                    if (userId)
+                        return sendTextReplyByOpenId(userId, toastContent);
+                    log.warn('[handleCardAction] No chatId/userId, cannot send text reply');
+                };
+                const p = sendReply();
+                if (p)
+                    p.catch((e) => log.warn('[handleCardAction] Send reply failed:', e));
+                // 同步只返回 toast，避免 200672（同步返回 card 格式易出错）
+                const cardToken = extractCardToken(data);
+                const readOnlyCard = createFeishuModeCardReadOnly(label);
+                if (cardToken && userId) {
+                    // 延时更新：异步替换为只读卡片，防止二次点击
+                    delayUpdateCard(cardToken, readOnlyCard, [userId]).catch((e) => log.warn('[handleCardAction] delayUpdateCard failed:', e));
+                }
+                else if (!cardToken) {
+                    log.debug('[handleCardAction] No card token in event, cannot delay-update card');
+                }
+                return { toast: { type: 'success', content: toastContent } };
+            }
+        }
+        const parsed = parsePermissionActionValue(actionValue);
+        if (!parsed) {
+            log.info('[handleCardAction] Unrecognized action value, returning default toast');
+            return { toast: { type: 'warning', content: '未知操作' } };
+        }
+        const { decision, requestId } = parsed;
+        log.info(`[handleCardAction] Permission button: ${decision} for ${requestId}, chatId=${chatId}`);
+        const resolved = resolvePermissionById(requestId, decision);
+        const toastContent = resolved
+            ? decision === 'allow'
+                ? '✅ 权限已允许'
+                : '❌ 权限已拒绝'
+            : '⚠️ 权限请求已过期或不存在';
+        const sendPermReply = () => {
+            if (chatId)
+                return sendTextReply(chatId, toastContent);
+            if (userId)
+                return sendTextReplyByOpenId(userId, toastContent);
+        };
+        const permP = sendPermReply();
+        if (permP)
+            permP.catch((err) => log.warn('Failed to send permission reply:', err));
+        return { toast: { type: resolved ? 'success' : 'warning', content: toastContent } };
+    }
     async function handleEvent(data) {
-        log.info('[handleEvent] Called with data:', JSON.stringify(data).slice(0, 500));
+        log.info('[handleEvent] Called with data:', JSON.stringify(data).slice(0, 800));
         try {
-            log.info('[handleEvent] Starting processing');
-            // Parse the event data
-            // Feishu event structure (long connection mode):
-            // {
-            //   "event_type": "im.message.receive_v1",
-            //   "event_id": "...",
-            //   "tenant_key": "...",
-            //   "app_id": "...",
-            //   "message": { "chat_id": "...", "content": "...", ... },
-            //   "sender": { "sender_id": { "open_id": "..." } }
-            // }
-            const event = data;
-            const eventType = event?.event_type;
+            const raw = data;
+            const event = (raw?.event ?? raw);
+            const eventType = event?.event_type ?? event?.type;
             log.info('Feishu event type:', eventType);
-            // Handle message received events
+            // 1. 卡片按钮点击 (card.action.trigger) - 需快速返回响应
+            if (eventType === 'card.action.trigger') {
+                const result = await handleCardAction(data);
+                return result ?? { toast: { type: 'success', content: '已处理' } };
+            }
+            // 2. 消息接收 (im.message.receive_v1)
             if (eventType === 'im.message.receive_v1') {
                 log.info('[handleEvent] Processing im.message.receive_v1 event');
+                // 兼容：部分场景下卡片点击可能通过 im.message 携带 action
+                if (event?.action?.value) {
+                    const parsed = parsePermissionActionValue(event.action.value);
+                    if (parsed) {
+                        const { decision, requestId } = parsed;
+                        const chatId = event.message?.chat_id ?? '';
+                        log.info(`[handleEvent] Permission (via msg): ${decision} for ${requestId}`);
+                        const resolved = resolvePermissionById(requestId, decision);
+                        if (resolved) {
+                            await sendTextReply(chatId, decision === 'allow' ? '✅ 权限已允许' : '❌ 权限已拒绝');
+                        }
+                        else {
+                            await sendTextReply(chatId, '⚠️ 权限请求已过期或不存在');
+                        }
+                        return;
+                    }
+                }
                 const message = event?.message;
                 if (!message) {
                     log.warn('No message data in event');
@@ -176,6 +378,7 @@ export function setupFeishuHandlers(config, sessionManager) {
                 }
                 log.info(`Access granted for sender: ${senderId}`);
                 setActiveChatId('feishu', chatId);
+                setChatUser(chatId, senderId);
                 // Handle different message types
                 if (msgType === 'text') {
                     const text = content.text?.trim() ?? '';
@@ -209,39 +412,42 @@ export function setupFeishuHandlers(config, sessionManager) {
                 }
                 else if (msgType === 'post') {
                     // Feishu rich text/post messages - extract text content
-                    const post = content?.post;
+                    // 支持 post.content 或 zh_cn.content，content 可能是二维数组（段落→元素）
+                    const post = content?.post
+                        ?? content?.zh_cn;
+                    const rawContent = post?.content;
                     let text = '';
-                    if (post?.content && Array.isArray(post.content)) {
-                        // Log full structure for debugging
-                        log.info(`[MSG] Post content structure:`, JSON.stringify(post.content).slice(0, 500));
-                        // Extract text from rich text structure
-                        for (const section of post.content) {
-                            if (!section || typeof section !== 'object')
-                                continue;
-                            const tag = section?.tag;
-                            // Handle different content types
-                            if (tag === 'text' || tag === 'plain_text') {
-                                const t = section?.text ?? '';
-                                text += t;
+                    function extractTextFromElement(el) {
+                        if (!el || typeof el !== 'object')
+                            return '';
+                        const obj = el;
+                        const tag = obj.tag;
+                        if (tag === 'text' || tag === 'plain_text') {
+                            return (obj.text ?? obj.content ?? '').toString();
+                        }
+                        if (tag === 'a')
+                            return (obj.text ?? obj.content ?? '').toString();
+                        if (tag === 'heading' || tag === 'heading1' || tag === 'heading2' || tag === 'heading3') {
+                            const headingText = el.text;
+                            if (typeof headingText === 'string')
+                                return headingText;
+                            if (Array.isArray(headingText)) {
+                                return headingText.map(extractTextFromElement).join('');
                             }
-                            else if (tag === 'heading' || tag === 'heading1' || tag === 'heading2' || tag === 'heading3') {
-                                // Handle headings - might be nested structure
-                                const headingText = section?.text;
-                                if (typeof headingText === 'string') {
-                                    text += headingText;
-                                }
-                                else if (Array.isArray(headingText)) {
-                                    // Nested text elements in heading
-                                    for (const item of headingText) {
-                                        if (item && typeof item === 'object' && 'text' in item) {
-                                            text += item.text ?? '';
-                                        }
-                                    }
+                        }
+                        return '';
+                    }
+                    if (rawContent && Array.isArray(rawContent)) {
+                        log.info(`[MSG] Post content structure:`, JSON.stringify(rawContent).slice(0, 500));
+                        for (const section of rawContent) {
+                            if (Array.isArray(section)) {
+                                // 二维数组：段落内多个元素
+                                for (const el of section) {
+                                    text += extractTextFromElement(el);
                                 }
                             }
                             else {
-                                // Log unhandled tags for debugging
-                                log.info(`[MSG] Unhandled post tag: ${tag}, section:`, JSON.stringify(section).slice(0, 200));
+                                text += extractTextFromElement(section);
                             }
                         }
                     }

package/dist/feishu/message-sender.d.ts

@@ -1,7 +1,29 @@
 export type MessageStatus = 'thinking' | 'streaming' | 'done' | 'error';
+/**
+ * Create Feishu card with action buttons
+ * Used for permission prompts and other interactive requests
+ */
+export declare function createFeishuButtonCard(title: string, content: string, buttons: Array<{
+    label: string;
+    value: string;
+    type?: 'primary' | 'default';
+}>): string;
+/** 只读模式卡片（无按钮，用于回调后替换原卡片防止二次点击） */
+export declare function createFeishuModeCardReadOnly(currentMode: string): Record<string, unknown>;
+/**
+ * 延时更新消息卡片（POST /open-apis/im/v1/cards/update）
+ * 用于在卡片回调 3 秒内无法完成时，异步替换卡片为只读版本，防止二次点击
+ * @param token 从卡片交互事件中获取的 token（格式 c-xxxx）
+ * @param card 卡片内容 { config, header, elements }
+ * @param openIds 非共享卡片需指定更新的用户 open_id 列表
+ */
+export declare function delayUpdateCard(token: string, card: Record<string, unknown>, openIds?: string[]): Promise<void>;
+export declare function sendModeCard(chatId: string, _userId: string, currentMode: string): Promise<void>;
 export declare function sendThinkingMessage(chatId: string, replyToMessageId: string | undefined, toolId?: string): Promise<string>;
 export declare function updateMessage(chatId: string, messageId: string, content: string, status: MessageStatus, note?: string, toolId?: string): Promise<void>;
 export declare function sendFinalMessages(chatId: string, messageId: string, fullContent: string, note: string, toolId?: string): Promise<void>;
 export declare function sendTextReply(chatId: string, text: string): Promise<void>;
+/** 使用 open_id 发送（私聊时 context 可能只有 open_id） */
+export declare function sendTextReplyByOpenId(openId: string, text: string): Promise<void>;
 export declare function sendImageReply(chatId: string, imagePath: string): Promise<void>;
 export declare function startTypingLoop(_chatId: string): () => void;

package/dist/feishu/message-sender.js

@@ -61,6 +61,161 @@ function createFeishuCard(title, content, status, note) {
     };
     return JSON.stringify(card);
 }
+/**
+ * Create Feishu card with action buttons
+ * Used for permission prompts and other interactive requests
+ */
+export function createFeishuButtonCard(title, content, buttons) {
+    const elements = [];
+    // Main content
+    elements.push({
+        tag: 'div',
+        text: {
+            tag: 'lark_md',
+            content: content,
+        },
+    });
+    // Add separator
+    elements.push({ tag: 'hr' });
+    // Add action buttons
+    const actionGroups = [];
+    // Split buttons into rows (max 4 buttons per row in Feishu)
+    for (let i = 0; i < buttons.length; i += 4) {
+        const row = buttons.slice(i, i + 4).map((btn) => ({
+            tag: 'button',
+            text: {
+                tag: 'plain_text',
+                content: btn.label,
+            },
+            type: btn.type || 'default',
+            value: {
+                action: 'permission',
+                value: btn.value,
+            },
+        }));
+        actionGroups.push({
+            tag: 'action',
+            actions: row,
+        });
+    }
+    elements.push(...actionGroups);
+    const card = {
+        config: {
+            wide_screen_mode: true,
+        },
+        header: {
+            template: 'blue',
+            title: {
+                content: `🔐 ${title}`,
+                tag: 'plain_text',
+            },
+        },
+        elements,
+    };
+    return JSON.stringify(card);
+}
+/** 只读模式卡片（无按钮，用于回调后替换原卡片防止二次点击） */
+export function createFeishuModeCardReadOnly(currentMode) {
+    return {
+        config: { wide_screen_mode: true },
+        header: {
+            template: 'green',
+            title: { content: '🔐 权限模式', tag: 'plain_text' },
+        },
+        elements: [
+            {
+                tag: 'div',
+                text: {
+                    tag: 'lark_md',
+                    content: `**当前模式:** ${currentMode}\n\n✅ 已切换成功，发送 \`/mode\` 可再次切换。`,
+                },
+            },
+        ],
+    };
+}
+/**
+ * 延时更新消息卡片（POST /open-apis/im/v1/cards/update）
+ * 用于在卡片回调 3 秒内无法完成时，异步替换卡片为只读版本，防止二次点击
+ * @param token 从卡片交互事件中获取的 token（格式 c-xxxx）
+ * @param card 卡片内容 { config, header, elements }
+ * @param openIds 非共享卡片需指定更新的用户 open_id 列表
+ */
+export async function delayUpdateCard(token, card, openIds) {
+    const accessToken = await getTenantAccessToken();
+    // 非共享卡片需在 card 内指定 open_ids
+    const cardBody = { ...card };
+    if (openIds && openIds.length > 0) {
+        cardBody.open_ids = openIds;
+    }
+    const body = { token, card: cardBody };
+    const resp = await fetch('https://open.feishu.cn/open-apis/interactive/v1/card/update', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${accessToken}`,
+        },
+        body: JSON.stringify(body),
+    });
+    const data = (await resp.json());
+    if (data.code !== 0) {
+        log.warn(`[delayUpdateCard] Failed: code=${data.code}, msg=${data.msg}`);
+        return;
+    }
+    log.info('[delayUpdateCard] Card updated successfully');
+}
+/**
+ * Create mode switch card with action type for card callback
+ */
+function createFeishuModeCard(currentMode, buttons) {
+    const elements = [];
+    elements.push({
+        tag: 'div',
+        text: {
+            tag: 'lark_md',
+            content: `**当前模式:** ${currentMode}\n\n点击下方按钮切换模式：\n\n_💡 若点击报错：开放平台 → 事件与回调 → 切到「回调」Tab → 添加「卡片回传交互」。或直接用 \`/mode ask\` 等命令切换。_`,
+        },
+    });
+    elements.push({ tag: 'hr' });
+    for (let i = 0; i < buttons.length; i += 4) {
+        const row = buttons.slice(i, i + 4).map((btn) => ({
+            tag: 'button',
+            text: { tag: 'plain_text', content: btn.label },
+            type: btn.type || 'default',
+            value: { action: 'mode', value: btn.value },
+        }));
+        elements.push({ tag: 'action', actions: row });
+    }
+    const card = {
+        config: { wide_screen_mode: true },
+        header: {
+            template: 'blue',
+            title: { content: '🔐 权限模式', tag: 'plain_text' },
+        },
+        elements,
+    };
+    return JSON.stringify(card);
+}
+export async function sendModeCard(chatId, _userId, currentMode) {
+    const { getClient } = await import('./client.js');
+    const { MODE_LABELS } = await import('../permission-mode/types.js');
+    const client = getClient();
+    const MODE_BTNS = [
+        { label: MODE_LABELS.ask, value: 'ask', type: 'default' },
+        { label: MODE_LABELS['accept-edits'], value: 'accept-edits', type: 'default' },
+        { label: MODE_LABELS.plan, value: 'plan', type: 'default' },
+        { label: MODE_LABELS.yolo, value: 'yolo', type: 'default' },
+    ];
+    const currentLabel = MODE_BTNS.find((b) => b.value === currentMode)?.label ?? currentMode;
+    const cardContent = createFeishuModeCard(currentLabel, MODE_BTNS);
+    await client.im.message.create({
+        data: {
+            receive_id: chatId,
+            msg_type: 'interactive',
+            content: cardContent,
+        },
+        params: { receive_id_type: 'chat_id' },
+    });
+}
 async function getTenantAccessToken() {
     const client = getClient();
     const resp = await client.auth.tenantAccessToken.internal({
@@ -100,8 +255,7 @@ export async function sendThinkingMessage(chatId, replyToMessageId, toolId = 'cl
 }
 export async function updateMessage(chatId, messageId, content, status, note, toolId = 'claude') {
     const client = getClient();
-    const icon = STATUS_CONFIG[status].icon;
-    const title = `${icon} ${getToolTitle(toolId, status)}`;
+    const title = getToolTitle(toolId, status);
     const cardContent = createFeishuCard(title, content, status, note);
     // Try to use patch API for in-place update (streaming)
     try {
@@ -223,6 +377,24 @@ export async function sendTextReply(chatId, text) {
         log.error('Failed to send text:', err);
     }
 }
+/** 使用 open_id 发送（私聊时 context 可能只有 open_id） */
+export async function sendTextReplyByOpenId(openId, text) {
+    const client = getClient();
+    const cardContent = createFeishuCard('📢 open-im', text, 'done');
+    try {
+        await client.im.message.create({
+            data: {
+                receive_id: openId,
+                msg_type: 'interactive',
+                content: cardContent,
+            },
+            params: { receive_id_type: 'open_id' },
+        });
+    }
+    catch (err) {
+        log.error('Failed to send text by open_id:', err);
+    }
+}
 export async function sendImageReply(chatId, imagePath) {
     const client = getClient();
     try {

package/dist/hook/permission-server.d.ts

@@ -1,4 +1,37 @@
-export declare function resolveLatestPermission(_chatId: string, _decision: 'allow' | 'deny'): string | null;
-export declare function getPendingCount(_chatId: string): number;
-export declare function resolvePermissionById(_requestId: string, _decision: 'allow' | 'deny'): boolean;
-export declare function registerPermissionSender(_platform: string, _sender: unknown): void;
+/**
+ * Permission Server - Handles tool permission requests from Claude CLI
+ *
+ * When claudeSkipPermissions is false and not in yolo mode, Claude CLI will make
+ * HTTP requests to this server. We forward all requests to the user for approval;
+ * permission mode logic (ask/accept-edits/plan) is handled by Claude via --permission-mode.
+ */
+interface MessageSender {
+    sendTextReply(chatId: string, text: string): Promise<void>;
+    sendPermissionCard?(chatId: string, requestId: string, toolName: string, toolInput: string): Promise<void>;
+}
+/**
+ * Start the permission HTTP server
+ */
+export declare function startPermissionServer(port?: number): number;
+/**
+ * Stop the permission HTTP server
+ */
+export declare function stopPermissionServer(): void;
+/**
+ * Register the message sender for sending permission prompts
+ */
+export declare function registerPermissionSender(_platform: string, sender: MessageSender): void;
+/**
+ * Get the number of pending permission requests for a chat
+ */
+export declare function getPendingCount(chatId: string): number;
+/**
+ * Resolve the latest pending permission request for a chat
+ * Returns the requestId if found, null otherwise
+ */
+export declare function resolveLatestPermission(chatId: string, decision: 'allow' | 'deny'): string | null;
+/**
+ * Resolve a specific permission request by ID
+ */
+export declare function resolvePermissionById(requestId: string, decision: 'allow' | 'deny'): boolean;
+export {};