@kafca/agentdock 0.1.21 → 0.1.23

package/dist-electron/electron/local-core-refactor.test.js

@@ -14,10 +14,11 @@ const scheduled_conversation_executor_js_1 = require("../services/local-ai-core/
 const scheduler_run_lifecycle_js_1 = require("../services/local-ai-core/src/scheduler/scheduler-run-lifecycle.js");
 const lark_execution_policies_js_1 = require("../services/local-ai-core/src/scheduler/lark-execution-policies.js");
 const local_schedule_adapter_js_1 = require("../services/local-ai-core/src/scheduler/local-schedule-adapter.js");
-const local_core_weixin_gateway_js_1 = require("../services/local-ai-core/src/gateway/local-core-weixin-gateway.js");
-const local_core_lark_gateway_js_1 = require("../services/local-ai-core/src/gateway/local-core-lark-gateway.js");
+const local_core_weixin_gateway_js_1 = require("../services/local-ai-core/src/channel/weixin/local-core-weixin-gateway.js");
+const local_core_lark_gateway_js_1 = require("../services/local-ai-core/src/channel/lark/local-core-lark-gateway.js");
 const local_core_acp_turn_coordinator_js_1 = require("../services/local-ai-core/src/acp/local-core-acp-turn-coordinator.js");
 const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/local-core-acp-store.js");
+const workspace_acp_permissions_js_1 = require("../services/local-ai-core/src/acp/workspace-acp-permissions.js");
 (0, node_test_1.default)('ACP tool call update is emitted with its pending tool name', () => {
     const appended = [];
     const emitted = [];
@@ -71,6 +72,29 @@ const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/loc
     strict_1.default.equal(emitted.length, 1);
     strict_1.default.equal(emitted[0]?.content, appended[0]?.content);
 });
+(0, node_test_1.default)('ACP permission normalization treats allow_all as allow all', () => {
+    strict_1.default.equal((0, workspace_acp_permissions_js_1.normalizePermissionAction)('allow_all'), 'allow all');
+    strict_1.default.equal((0, workspace_acp_permissions_js_1.normalizePermissionAction)('allow_always'), 'allow all');
+    strict_1.default.equal((0, workspace_acp_permissions_js_1.normalizePermissionAction)('always'), 'allow all');
+    strict_1.default.equal((0, workspace_acp_permissions_js_1.normalizePermissionAction)('allow_once'), 'allow');
+});
+(0, node_test_1.default)('ACP permission normalization preserves always-allow option semantics', () => {
+    strict_1.default.equal((0, workspace_acp_permissions_js_1.normalizePermissionOptionAction)({
+        optionId: 'approve',
+        name: 'Always allow',
+        kind: 'allow',
+    }), 'allow all');
+    strict_1.default.equal((0, workspace_acp_permissions_js_1.normalizePermissionOptionAction)({
+        optionId: 'allow-all-tools',
+        name: '始终允许',
+        kind: 'allow',
+    }), 'allow all');
+    strict_1.default.equal((0, workspace_acp_permissions_js_1.normalizePermissionOptionAction)({
+        optionId: 'allow_once',
+        name: 'Allow once',
+        kind: 'allow',
+    }), 'allow');
+});
 (0, node_test_1.default)('ACP tool call running and completed updates share one message id', () => {
     const upserted = [];
     const emitted = [];
@@ -305,6 +329,55 @@ const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/loc
     strict_1.default.match(upserted[0]?.content || '', /ls -la ~\/Desktop/);
     strict_1.default.match(upserted[0]?.content || '', /completed - Desktop file list/);
 });
+(0, node_test_1.default)('ACP permission button rows preserve always allow actions', () => {
+    const emitted = [];
+    const coordinator = new local_core_acp_turn_coordinator_js_1.LocalCoreAcpTurnCoordinator({
+        appendMessage: () => { },
+        emitBridge: (event) => emitted.push(event),
+        updateRunStatus: () => { },
+        sendRaw: () => true,
+    });
+    const session = {
+        threadId: 'thread-1',
+        bridgeSessionKey: 'session:thread-1',
+        currentRunId: 'run-1',
+        currentTurn: {
+            runId: 'run-1',
+            replyCtx: 'run-1',
+            previewHandle: 'preview-1',
+            assistantText: '',
+            typingStarted: true,
+            previewStarted: false,
+            permission: null,
+        },
+        pendingPermissionByRun: new Map(),
+        loadReplayMode: false,
+        schedulerJobCreatedByRun: new Map(),
+    };
+    coordinator.handleAgentRequest(session, {
+        method: 'session/request_permission',
+        id: 42,
+        params: {
+            toolCall: {
+                title: 'Terminal',
+                parameters: {
+                    command: 'system_profiler SPHardwareDataType',
+                },
+            },
+            options: [
+                { optionId: 'approve-once', name: 'Allow once', kind: 'allow' },
+                { optionId: 'approve-always', name: 'Always allow', kind: 'allow' },
+                { optionId: 'reject', name: 'Reject', kind: 'reject' },
+            ],
+        },
+    });
+    strict_1.default.deepEqual(emitted[0]?.buttonRows, [[
+            { text: 'allow', data: 'allow' },
+            { text: 'allow all', data: 'allow all' },
+            { text: 'deny', data: 'deny' },
+        ]]);
+    strict_1.default.equal(session.pendingPermissionByRun.get('run-1')?.options[1]?.optionId, 'approve-always');
+});
 (0, node_test_1.default)('ACP bare tool call is flushed before assistant text', () => {
     const appended = [];
     const emitted = [];
@@ -573,6 +646,81 @@ const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/loc
     strict_1.default.equal(patchedCards[0]?.text, '💭 先理解问题，再检查代码');
     strict_1.default.deepEqual(storedMessageIds, ['lark-msg-2']);
 });
+(0, node_test_1.default)('lark bridge sends final reply as a separate card after streamed final updates', async () => {
+    const createdCards = [];
+    const patchedCards = [];
+    const storedMessageIds = [];
+    const client = {
+        im: {
+            message: {
+                create: async (request) => {
+                    const messageId = `lark-msg-${createdCards.length + 1}`;
+                    const card = JSON.parse(String(request.data.content || '{}'));
+                    createdCards.push({
+                        messageId,
+                        text: String(card.elements?.[0]?.content || ''),
+                    });
+                    return { data: { message_id: messageId } };
+                },
+                patch: async (request) => {
+                    const card = JSON.parse(String(request.data.content || '{}'));
+                    patchedCards.push({
+                        messageId: String(request.path.message_id || ''),
+                        text: String(card.elements?.[0]?.content || ''),
+                    });
+                },
+            },
+        },
+    };
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+            updatePlatformThreadMessageId: (_workspaceId, _chatId, _platformUserId, messageId) => {
+                storedMessageIds.push(messageId);
+            },
+        },
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        client,
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    await gateway.onBridgeEvent({
+        type: 'update_message',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        content: '流式中的最终回答草稿',
+    });
+    await gateway.onBridgeEvent({
+        type: 'reply',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        content: '真正最终回答',
+    });
+    strict_1.default.deepEqual(createdCards.map((card) => card.text), ['流式中的最终回答草稿', '真正最终回答']);
+    strict_1.default.equal(patchedCards.length, 0);
+    strict_1.default.deepEqual(storedMessageIds, ['lark-msg-1', 'lark-msg-2']);
+});
 (0, node_test_1.default)('lark bridge does not leave typing placeholders or throttle thought updates', async () => {
     const createdCards = [];
     const patchedCards = [];
@@ -669,6 +817,7 @@ const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/loc
 });
 (0, node_test_1.default)('lark permission requests render as clickable card buttons', async () => {
     const createdCards = [];
+    const patchedCards = [];
     const threadActions = [];
     const client = {
         im: {
@@ -677,7 +826,12 @@ const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/loc
                     createdCards.push(JSON.parse(String(request.data.content || '{}')));
                     return { data: { message_id: 'permission-msg-1' } };
                 },
-                patch: async () => { },
+                patch: async (request) => {
+                    patchedCards.push({
+                        messageId: request.path?.message_id,
+                        card: JSON.parse(String(request.data.content || '{}')),
+                    });
+                },
             },
         },
     };
@@ -757,13 +911,244 @@ const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/loc
                     action: 'permission_response',
                     response: 'allow all',
                     thread_id: 'thread-1',
+                    session_key: 'session:thread-1',
                 },
             },
+            context: {
+                open_message_id: 'permission-msg-1',
+            },
         },
     });
     strict_1.default.deepEqual(threadActions, [
         { threadId: 'thread-1', action: 'allow all' },
     ]);
+    strict_1.default.equal(patchedCards.length, 1);
+    strict_1.default.equal(patchedCards[0]?.messageId, 'permission-msg-1');
+    strict_1.default.match(patchedCards[0]?.card?.elements?.[0]?.content || '', /工具确认已处理/);
+    strict_1.default.equal(patchedCards[0]?.card?.elements?.some((element) => element.tag === 'action'), false);
+});
+(0, node_test_1.default)('lark allow all card action preserves the final reply after tool execution', async () => {
+    const createdCards = [];
+    const patchedCards = [];
+    let nextMessageId = 1;
+    let gateway;
+    const client = {
+        im: {
+            message: {
+                create: async (request) => {
+                    const messageId = `card-${nextMessageId++}`;
+                    createdCards.push({
+                        messageId,
+                        card: JSON.parse(String(request.data.content || '{}')),
+                    });
+                    return { data: { message_id: messageId } };
+                },
+                patch: async (request) => {
+                    patchedCards.push({
+                        messageId: request.path?.message_id,
+                        card: JSON.parse(String(request.data.content || '{}')),
+                    });
+                },
+            },
+        },
+    };
+    gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+            clearPlatformThreadMessageId: () => { },
+            updatePlatformThreadMessageId: () => { },
+        },
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({
+            sendThreadAction: async (threadId, action) => {
+                strict_1.default.equal(threadId, 'thread-1');
+                strict_1.default.equal(action, 'allow all');
+                await gateway.onBridgeEvent({
+                    type: 'typing_start',
+                    sessionKey: 'session:thread-1',
+                    replyCtx: 'run-1',
+                });
+                await gateway.onBridgeEvent({
+                    type: 'reply',
+                    sessionKey: 'session:thread-1',
+                    replyCtx: 'run-1',
+                    content: '桌面文件列表：AI进展报告_2026年4月.md',
+                });
+                return { runId: 'run-1' };
+            },
+        }),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        cardActionsEnabled: true,
+        client,
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    internals.outboundTurns.set('session:thread-1', {
+        sessionKey: 'session:thread-1',
+        progressMessageIds: {},
+        permissionMessageId: 'permission-msg-1',
+        awaitingPermission: true,
+        processing: true,
+        previewText: '',
+        finalText: '',
+        thinkingSteps: [],
+        toolCalls: [],
+        statusLines: [],
+        buttonRows: [[{ text: '始终允许', data: 'allow all' }]],
+        lastPatchedAt: 0,
+        lastPatchedAtByMessageId: {},
+    });
+    await internals.handleCardActionEvent('default', {
+        event: {
+            action: {
+                value: {
+                    action: 'permission_response',
+                    response: 'allow all',
+                    thread_id: 'thread-1',
+                    session_key: 'session:thread-1',
+                },
+            },
+            context: {
+                open_message_id: 'permission-msg-1',
+            },
+        },
+    });
+    strict_1.default.equal(patchedCards[0]?.messageId, 'permission-msg-1');
+    strict_1.default.match(patchedCards[0]?.card?.elements?.[0]?.content || '', /工具确认已处理/);
+    strict_1.default.equal(createdCards.length, 1);
+    strict_1.default.match(createdCards[0]?.card?.elements?.[0]?.content || '', /桌面文件列表/);
+});
+(0, node_test_1.default)('lark channel folds tool result output in progress cards', async () => {
+    const createdCards = [];
+    const patchedCards = [];
+    const client = {
+        im: {
+            message: {
+                create: async (request) => {
+                    createdCards.push(JSON.parse(String(request.data.content || '{}')));
+                    return { data: { message_id: 'tool-msg-1' } };
+                },
+                patch: async (request) => {
+                    patchedCards.push(JSON.parse(String(request.data.content || '{}')));
+                },
+            },
+        },
+    };
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+        },
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        client,
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    await gateway.onBridgeEvent({
+        type: 'reply',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        messageId: 'tool-1',
+        content: '🔧 Terminal: ls - completed - secret terminal output',
+    });
+    const text = createdCards[0]?.elements?.[0]?.content || patchedCards[0]?.elements?.[0]?.content || '';
+    strict_1.default.match(text, /Terminal: ls - completed/);
+    strict_1.default.doesNotMatch(text, /secret terminal output/);
+});
+(0, node_test_1.default)('lark card action message id can be extracted from full callback payload', async () => {
+    const patchedCards = [];
+    const threadActions = [];
+    const client = {
+        im: {
+            message: {
+                patch: async (request) => {
+                    patchedCards.push({
+                        messageId: request.path?.message_id,
+                        card: JSON.parse(String(request.data.content || '{}')),
+                    });
+                },
+            },
+        },
+    };
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {},
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({
+            sendThreadAction: async (threadId, action) => {
+                threadActions.push({ threadId, action });
+                return { runId: 'run-1' };
+            },
+        }),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        client,
+    });
+    await internals.handleCardActionEvent('default', {
+        schema: '2.0',
+        event: {
+            action: {
+                value: {
+                    action: 'permission_response',
+                    response: 'allow',
+                    thread_id: 'thread-1',
+                },
+            },
+        },
+        event_context: {
+            open_message_id: 'permission-msg-nested',
+        },
+    });
+    strict_1.default.deepEqual(threadActions, [
+        { threadId: 'thread-1', action: 'allow' },
+    ]);
+    strict_1.default.equal(patchedCards[0]?.messageId, 'permission-msg-nested');
+    strict_1.default.equal(patchedCards[0]?.card?.elements?.some((element) => element.tag === 'action'), false);
 });
 (0, node_test_1.default)('lark permission requests fall back to text commands when card actions are disabled', async () => {
     const createdCards = [];
@@ -917,6 +1302,183 @@ const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/loc
     strict_1.default.equal(sentMessages[0]?.content?.contentParts?.[1]?.mimeType, 'image/png');
     strict_1.default.equal(sentMessages[0]?.content?.contentParts?.[1]?.data, pngBytes.toString('base64'));
 });
+(0, node_test_1.default)('lark channel can upload and send a local file', async () => {
+    const tempDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'lark-file-send-'));
+    try {
+        const filePath = (0, node_path_1.join)(tempDir, 'report.pdf');
+        (0, node_fs_1.writeFileSync)(filePath, 'pdf content');
+        const uploads = [];
+        const messages = [];
+        const client = {
+            im: {
+                file: {
+                    create: async (request) => {
+                        uploads.push(request);
+                        await new Promise((resolve, reject) => {
+                            request.data.file.on('data', () => { });
+                            request.data.file.on('error', reject);
+                            request.data.file.on('end', resolve);
+                        });
+                        return { file_key: 'file-key-1' };
+                    },
+                },
+                message: {
+                    create: async (request) => {
+                        messages.push(request);
+                        return { data: { message_id: 'msg-file-1' } };
+                    },
+                },
+            },
+        };
+        const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+            store: {},
+            readConfig: async () => null,
+            getWorkspaceRouter: () => ({}),
+            eventBus: { emit: () => { }, on: () => () => { } },
+        });
+        const internals = gateway;
+        internals.runtime.set('default', {
+            workspaceId: 'default',
+            enabled: true,
+            status: 'running',
+            connected: true,
+            appId: 'app-1',
+            client,
+        });
+        const result = await gateway.sendFile('default', {
+            path: filePath,
+            channelId: 'oc_chat_1',
+        });
+        strict_1.default.equal(uploads.length, 1);
+        strict_1.default.equal(uploads[0]?.data?.file_type, 'pdf');
+        strict_1.default.equal(uploads[0]?.data?.file_name, 'report.pdf');
+        strict_1.default.equal(messages.length, 1);
+        strict_1.default.equal(messages[0]?.params?.receive_id_type, 'chat_id');
+        strict_1.default.equal(messages[0]?.data?.receive_id, 'oc_chat_1');
+        strict_1.default.equal(messages[0]?.data?.msg_type, 'file');
+        strict_1.default.deepEqual(JSON.parse(messages[0]?.data?.content), { file_key: 'file-key-1' });
+        strict_1.default.deepEqual(result, {
+            platform: 'lark',
+            workspaceId: 'default',
+            channelId: 'oc_chat_1',
+            messageId: 'msg-file-1',
+            fileKey: 'file-key-1',
+            fileName: 'report.pdf',
+            fileSize: Buffer.byteLength('pdf content'),
+        });
+    }
+    finally {
+        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('weixin channel can encrypt, upload, and send a local file', async () => {
+    const tempDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'weixin-file-send-'));
+    const originalFetch = globalThis.fetch;
+    try {
+        const filePath = (0, node_path_1.join)(tempDir, 'report.txt');
+        (0, node_fs_1.writeFileSync)(filePath, 'hello weixin');
+        const uploadUrlRequests = [];
+        const cdnUploads = [];
+        const sentMessages = [];
+        globalThis.fetch = (async (url, init) => {
+            const target = String(url);
+            if (target.endsWith('/ilink/bot/getuploadurl')) {
+                uploadUrlRequests.push(JSON.parse(String(init?.body || '{}')));
+                return {
+                    ok: true,
+                    json: async () => ({ ret: 0, upload_param: 'upload-param-1' }),
+                };
+            }
+            if (target.includes('/upload?')) {
+                const body = init?.body instanceof Uint8Array ? init.body : new Uint8Array();
+                cdnUploads.push({ url: target, size: body.byteLength });
+                return {
+                    ok: true,
+                    headers: {
+                        get: (name) => name.toLowerCase() === 'x-encrypted-param' ? 'download-param-1' : null,
+                    },
+                };
+            }
+            if (target.endsWith('/ilink/bot/sendmessage')) {
+                sentMessages.push(JSON.parse(String(init?.body || '{}')));
+                return {
+                    ok: true,
+                    json: async () => ({ ret: 0 }),
+                };
+            }
+            throw new Error(`Unexpected fetch ${target}`);
+        });
+        const gateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+            store: {
+                getPlatformThreadBinding: () => ({
+                    workspace_id: 'default',
+                    platform: 'weixin',
+                    chat_id: 'user-1',
+                    platform_user_id: 'user-1',
+                    thread_id: 'thread-1',
+                    last_platform_message_id: 'ctx-1',
+                }),
+                listAuthorizedUsers: () => [],
+            },
+            readConfig: async () => ({
+                projects: [{
+                        name: 'default',
+                        root: '/tmp/project',
+                        platforms: [{
+                                type: 'weixin',
+                                options: {
+                                    token: 'token-1',
+                                    account_id: 'account-1',
+                                    base_url: 'https://weixin.example',
+                                    cdn_base_url: 'https://cdn.example/c2c',
+                                },
+                            }],
+                    }],
+            }),
+            getWorkspaceRouter: () => ({}),
+            eventBus: { emit: () => { }, on: () => () => { } },
+        });
+        const internals = gateway;
+        internals.runtime.set('default', {
+            workspaceId: 'default',
+            enabled: true,
+            status: 'running',
+            connected: true,
+            accountId: 'account-1',
+        });
+        const result = await gateway.sendFile('default', {
+            path: filePath,
+            channelId: 'user-1',
+            participantId: 'user-1',
+        });
+        strict_1.default.equal(uploadUrlRequests.length, 1);
+        strict_1.default.equal(uploadUrlRequests[0]?.media_type, 3);
+        strict_1.default.equal(uploadUrlRequests[0]?.to_user_id, 'user-1');
+        strict_1.default.equal(uploadUrlRequests[0]?.rawsize, Buffer.byteLength('hello weixin'));
+        strict_1.default.equal(uploadUrlRequests[0]?.filesize, 16);
+        strict_1.default.equal(cdnUploads.length, 1);
+        strict_1.default.match(cdnUploads[0]?.url || '', /encrypted_query_param=upload-param-1/);
+        strict_1.default.equal(cdnUploads[0]?.size, 16);
+        strict_1.default.equal(sentMessages.length, 1);
+        const message = sentMessages[0]?.msg;
+        strict_1.default.equal(message?.to_user_id, 'user-1');
+        strict_1.default.equal(message?.context_token, 'ctx-1');
+        strict_1.default.equal(message?.item_list?.[0]?.type, 4);
+        strict_1.default.equal(message?.item_list?.[0]?.file_item?.file_name, 'report.txt');
+        strict_1.default.equal(message?.item_list?.[0]?.file_item?.len, String(Buffer.byteLength('hello weixin')));
+        strict_1.default.equal(message?.item_list?.[0]?.file_item?.media?.encrypt_query_param, 'download-param-1');
+        strict_1.default.equal(result.platform, 'weixin');
+        strict_1.default.equal(result.channelId, 'user-1');
+        strict_1.default.equal(result.fileName, 'report.txt');
+        strict_1.default.equal(result.fileSize, Buffer.byteLength('hello weixin'));
+        strict_1.default.match(result.messageId, /^openclaw-weixin-/);
+        strict_1.default.ok(result.fileKey);
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('lark message callbacks acknowledge before long thread runs finish', async () => {
     let registeredHandlers = {};
     let sentMessages = 0;
@@ -1006,6 +1568,80 @@ const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/loc
         line.includes('sender=user-1')));
     strict_1.default.ok(logs.some((line) => line.includes('handling message event') && line.includes('contentBytes=')));
 });
+(0, node_test_1.default)('lark inbound messages use active runtime binding before config refresh catches up', async () => {
+    const users = new Map();
+    const threadBindings = new Map();
+    const createdThreads = [];
+    const sentCards = [];
+    const platformKey = 'lark:lark-hot';
+    const bindingKey = `${platformKey}:chat-1:user-1`;
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            expirePendingPairings: () => { },
+            listPendingPairings: () => [],
+            listAuthorizedUsers: () => [...users.values()],
+            getAuthorizedUser: (_workspaceId, platformUserId, requestedPlatform) => users.get(`${requestedPlatform}:${platformUserId}`),
+            createAuthorizedUser: (user) => users.set(`${user.platform}:${user.platform_user_id}`, user),
+            updateAuthorizedUserThread: (_workspaceId, platformUserId, threadId, requestedPlatform) => {
+                users.set(`${requestedPlatform}:${platformUserId}`, { ...users.get(`${requestedPlatform}:${platformUserId}`), thread_id: threadId });
+            },
+            getPlatformThreadBinding: () => threadBindings.get(bindingKey),
+            upsertPlatformThreadBinding: (binding) => threadBindings.set(bindingKey, binding),
+            getLatestRunForThread: () => null,
+            clearPlatformThreadMessageId: () => { },
+        },
+        readConfig: async () => ({ projects: [] }),
+        getWorkspaceRouter: () => ({
+            createThread: async (_workspaceId, title) => {
+                const id = `thread-${createdThreads.length + 1}`;
+                createdThreads.push(`${id}:${title}`);
+                return { id };
+            },
+            getThreadSessionKey: (threadId) => `session:${threadId}`,
+            sendThreadMessage: async () => ({ runId: 'run-1' }),
+        }),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('project-1::lark-hot', {
+        workspaceId: 'project-1',
+        instanceId: 'lark-hot',
+        displayName: 'Lark Hot',
+        platformKey,
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        autoApprove: true,
+        cardActionsEnabled: true,
+        client: {
+            im: {
+                message: {
+                    create: async (request) => {
+                        sentCards.push(JSON.parse(String(request.data.content || '{}')));
+                        return { data: { message_id: 'card-1' } };
+                    },
+                },
+                messageReaction: {
+                    create: async () => ({ data: { reaction_id: 'reaction-1' } }),
+                },
+            },
+        },
+    });
+    await gateway.handleInboundMessage({
+        workspaceId: 'project-1',
+        instanceId: 'lark-hot',
+        platformKey,
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        displayName: 'User',
+        text: '/new',
+        messageId: 'msg-1',
+    });
+    strict_1.default.equal(users.get(`${platformKey}:user-1`)?.thread_id, 'thread-2');
+    strict_1.default.deepEqual(createdThreads.map((item) => item.split(':')[0]), ['thread-1', 'thread-2']);
+    strict_1.default.match(sentCards[0]?.elements?.[0]?.content || '', /已开始新会话/);
+});
 (0, node_test_1.default)('ACP skips empty generic running tool updates', () => {
     const appended = [];
     const emitted = [];
@@ -1392,6 +2028,8 @@ const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/loc
             ticket: 'ticket-1',
             expiresIn: 180,
             qrCodeUrl: 'https://liteapp.weixin.qq.com/q/test?qrcode=ticket-1&bot_type=3',
+            instanceId: 'default',
+            displayName: 'WeChat 1',
         });
         strict_1.default.equal(requests[0]?.url, 'https://ilinkai.weixin.qq.com/ilink/bot/get_bot_qrcode?bot_type=3');
         strict_1.default.equal(requests[0]?.headers.has('Authorization'), false);
@@ -1460,6 +2098,177 @@ const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/loc
         (0, node_fs_1.rmSync)(stateDir, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('lark channel can request an official app registration QR code without extra setup', async () => {
+    const originalFetch = globalThis.fetch;
+    const requests = [];
+    globalThis.fetch = (async (input, init) => {
+        requests.push({
+            url: String(input),
+            method: init?.method,
+            body: String(init?.body || ''),
+            headers: new Headers(init?.headers),
+        });
+        return new Response(JSON.stringify({
+            device_code: 'device-code-1',
+            user_code: 'ABCD-EFGH',
+            expires_in: 300,
+            interval: 5,
+        }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    });
+    try {
+        const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+            store: {},
+            readConfig: async () => ({
+                projects: [
+                    {
+                        name: 'default',
+                        agent: { type: 'localcore-acp', providers: [] },
+                        platforms: [{ type: 'lark', options: {} }],
+                    },
+                ],
+            }),
+            getWorkspaceRouter: () => ({}),
+            eventBus: { emit: () => { }, on: () => () => { } },
+        });
+        const result = await gateway.getQrCode('default');
+        strict_1.default.deepEqual(result, {
+            ticket: 'device-code-1',
+            expiresIn: 300,
+            interval: 5,
+            qrCodeUrl: 'https://open.feishu.cn/page/openclaw?user_code=ABCD-EFGH&from=openclaw',
+            instanceId: 'default',
+            displayName: 'Lark 1',
+        });
+        strict_1.default.equal(requests[0]?.url, 'https://accounts.feishu.cn/oauth/v1/app/registration');
+        strict_1.default.equal(requests[0]?.method, 'POST');
+        strict_1.default.equal(requests[0]?.headers.get('Content-Type'), 'application/x-www-form-urlencoded');
+        strict_1.default.equal(new URLSearchParams(requests[0]?.body).get('action'), 'begin');
+        strict_1.default.equal(new URLSearchParams(requests[0]?.body).get('archetype'), 'PersonalAgent');
+        strict_1.default.equal(new URLSearchParams(requests[0]?.body).get('request_callbacks'), null);
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});
+(0, node_test_1.default)('lark app registration QR confirmation returns app credentials', async () => {
+    const originalFetch = globalThis.fetch;
+    const requests = [];
+    globalThis.fetch = (async (input, init) => {
+        const url = String(input);
+        requests.push({ url, body: String(init?.body || '') });
+        return new Response(JSON.stringify({
+            client_id: 'cli_lark_1',
+            client_secret: 'secret-1',
+        }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    });
+    try {
+        const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+            store: {},
+            readConfig: async () => ({
+                projects: [
+                    {
+                        name: 'default',
+                        agent: { type: 'localcore-acp', providers: [] },
+                        platforms: [{ type: 'lark', options: {} }],
+                    },
+                ],
+            }),
+            getWorkspaceRouter: () => ({}),
+            eventBus: { emit: () => { }, on: () => () => { } },
+        });
+        const result = await gateway.checkQrCodeStatus('default', 'lark-ticket-1');
+        strict_1.default.equal(requests[0]?.url, 'https://accounts.feishu.cn/oauth/v1/app/registration');
+        strict_1.default.equal(new URLSearchParams(requests[0]?.body).get('action'), 'poll');
+        strict_1.default.equal(new URLSearchParams(requests[0]?.body).get('device_code'), 'lark-ticket-1');
+        strict_1.default.deepEqual(result, {
+            status: 'confirmed',
+            credentials: {
+                appId: 'cli_lark_1',
+                appSecret: 'secret-1',
+            },
+        });
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});
+(0, node_test_1.default)('lark channel keeps multiple bot instances in one workspace isolated', async () => {
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            expirePendingPairings: () => { },
+            listPendingPairings: () => [],
+            listAuthorizedUsers: () => [],
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'localcore-acp', providers: [] },
+                    platforms: [
+                        { type: 'lark', options: { instance_id: 'bot-a', app_id: 'cli_a', app_secret: 'secret-a' } },
+                        { type: 'lark', options: { instance_id: 'bot-b', app_id: 'cli_b', app_secret: 'secret-b' } },
+                    ],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    gateway.larkModulePromise = Promise.resolve({
+        AppType: { SelfBuild: 'self-build' },
+        Domain: { Feishu: 'feishu' },
+        LoggerLevel: { info: 'info' },
+        Client: class {
+        },
+        EventDispatcher: class {
+            register() { }
+        },
+        WSClient: class {
+            async start() { }
+        },
+    });
+    await gateway.refreshBindings();
+    const statuses = gateway.listStatuses();
+    strict_1.default.deepEqual(statuses.map((status) => [status.workspaceId, status.instanceId, status.appId, status.status]), [
+        ['default', 'bot-a', 'cli_a', 'running'],
+        ['default', 'bot-b', 'cli_b', 'running'],
+    ]);
+});
+(0, node_test_1.default)('weixin channel keeps multiple bot instances in one workspace isolated', async () => {
+    const gateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+        store: {
+            expirePendingPairings: () => { },
+            listPendingPairings: () => [],
+            listAuthorizedUsers: () => [],
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'localcore-acp', providers: [] },
+                    platforms: [
+                        { type: 'weixin', options: { instance_id: 'wx-a', account_id: 'account-a' } },
+                        { type: 'weixin', options: { instance_id: 'wx-b', account_id: 'account-b' } },
+                    ],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    await gateway.refreshBindings();
+    const statuses = gateway.listStatuses();
+    strict_1.default.deepEqual(statuses.map((status) => [status.workspaceId, status.instanceId, status.appId, status.status]), [
+        ['default', 'wx-a', 'account-a', 'stopped'],
+        ['default', 'wx-b', 'account-b', 'stopped'],
+    ]);
+});
 (0, node_test_1.default)('weixin inbound message handling is idempotent by message identity', async () => {
     const sentThreadMessages = [];
     const users = new Map();