@kafca/agentdock 0.1.19 → 0.1.21

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

@@ -8,12 +8,14 @@ const strict_1 = __importDefault(require("node:assert/strict"));
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
+const node_stream_1 = require("node:stream");
 const local_core_acp_response_processor_js_1 = require("../services/local-ai-core/src/acp/local-core-acp-response-processor.js");
 const scheduled_conversation_executor_js_1 = require("../services/local-ai-core/src/scheduler/scheduled-conversation-executor.js");
 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_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");
 (0, node_test_1.default)('ACP tool call update is emitted with its pending tool name', () => {
@@ -484,6 +486,526 @@ const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/loc
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('lark bridge keeps thought preview and final answer in separate messages', 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: 'preview_start',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        previewHandle: 'thought-preview-1',
+        content: '💭 先理解问题',
+    });
+    await gateway.onBridgeEvent({
+        type: 'update_message',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        previewHandle: 'thought-preview-1',
+        content: '💭 先理解问题，再检查代码',
+    });
+    await gateway.onBridgeEvent({
+        type: 'reply',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        content: '最终回答',
+    });
+    strict_1.default.equal(createdCards.length, 2);
+    strict_1.default.equal(createdCards[0]?.text, '💭 先理解问题');
+    strict_1.default.equal(createdCards[1]?.text, '最终回答');
+    strict_1.default.equal(patchedCards.length, 1);
+    strict_1.default.equal(patchedCards[0]?.messageId, 'lark-msg-1');
+    strict_1.default.equal(patchedCards[0]?.text, '💭 先理解问题，再检查代码');
+    strict_1.default.deepEqual(storedMessageIds, ['lark-msg-2']);
+});
+(0, node_test_1.default)('lark bridge does not leave typing placeholders or throttle thought updates', async () => {
+    const createdCards = [];
+    const patchedCards = [];
+    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: () => { },
+        },
+        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: 'typing_start',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+    });
+    await gateway.onBridgeEvent({
+        type: 'preview_start',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        previewHandle: 'thought-preview-1',
+        content: '💭 The user',
+    });
+    await gateway.onBridgeEvent({
+        type: 'update_message',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        previewHandle: 'thought-preview-1',
+        content: '💭 The user sent a short casual message.',
+    });
+    await gateway.onBridgeEvent({
+        type: 'update_message',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        previewHandle: 'thought-preview-1',
+        content: '💭 The user sent a short casual message. I should reply briefly.',
+    });
+    await gateway.onBridgeEvent({
+        type: 'typing_stop',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+    });
+    strict_1.default.deepEqual(createdCards.map((card) => card.text), ['💭 The user']);
+    strict_1.default.deepEqual(patchedCards.map((card) => card.text), [
+        '💭 The user sent a short casual message.',
+        '💭 The user sent a short casual message. I should reply briefly.',
+    ]);
+    strict_1.default.ok(!createdCards.some((card) => /处理中|正在思考/.test(card.text)));
+});
+(0, node_test_1.default)('lark permission requests render as clickable card buttons', async () => {
+    const createdCards = [];
+    const threadActions = [];
+    const client = {
+        im: {
+            message: {
+                create: async (request) => {
+                    createdCards.push(JSON.parse(String(request.data.content || '{}')));
+                    return { data: { message_id: 'permission-msg-1' } };
+                },
+                patch: async () => { },
+            },
+        },
+    };
+    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: () => ({
+            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',
+        cardActionsEnabled: true,
+        client,
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    await gateway.onBridgeEvent({
+        type: 'buttons',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        content: [
+            '等待工具确认',
+            '',
+            'Terminal',
+            '',
+            'parameters:',
+            '{"command":"ls"}',
+            '',
+            '请选择一个选项继续执行。',
+        ].join('\n'),
+        buttonRows: [[
+                { text: 'allow', data: 'allow' },
+                { text: 'allow all', data: 'allow all' },
+                { text: 'deny', data: 'deny' },
+            ]],
+    });
+    const actionElement = createdCards[0]?.elements?.find((element) => element.tag === 'action');
+    strict_1.default.equal(createdCards.length, 1);
+    strict_1.default.match(createdCards[0]?.elements?.[0]?.content || '', /需要工具确认/);
+    strict_1.default.deepEqual(actionElement?.actions?.map((action) => ({
+        label: action.text?.content,
+        type: action.type,
+        response: action.value?.response,
+        threadId: action.value?.thread_id,
+    })), [
+        { label: '允许一次', type: 'primary', response: 'allow', threadId: 'thread-1' },
+        { label: '始终允许', type: 'default', response: 'allow all', threadId: 'thread-1' },
+        { label: '拒绝', type: 'danger', response: 'deny', threadId: 'thread-1' },
+    ]);
+    await internals.handleCardActionEvent('default', {
+        event: {
+            action: {
+                value: {
+                    action: 'permission_response',
+                    response: 'allow all',
+                    thread_id: 'thread-1',
+                },
+            },
+        },
+    });
+    strict_1.default.deepEqual(threadActions, [
+        { threadId: 'thread-1', action: 'allow all' },
+    ]);
+});
+(0, node_test_1.default)('lark permission requests fall back to text commands when card actions are disabled', async () => {
+    const createdCards = [];
+    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',
+        cardActionsEnabled: false,
+        client: {
+            im: {
+                message: {
+                    create: async (request) => {
+                        createdCards.push(JSON.parse(String(request.data.content || '{}')));
+                        return { data: { message_id: 'permission-msg-1' } };
+                    },
+                    patch: async () => { },
+                },
+            },
+        },
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    await gateway.onBridgeEvent({
+        type: 'buttons',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        content: '等待工具确认\n\nTerminal\n\n请选择一个选项继续执行。',
+        buttonRows: [[
+                { text: 'allow', data: 'allow' },
+                { text: 'deny', data: 'deny' },
+            ]],
+    });
+    strict_1.default.equal(createdCards.length, 1);
+    strict_1.default.match(createdCards[0]?.elements?.[0]?.content || '', /请直接回复/);
+    strict_1.default.equal(createdCards[0]?.elements?.some((element) => element.tag === 'action'), false);
+});
+(0, node_test_1.default)('lark image messages are downloaded and forwarded as generic channel image parts', async () => {
+    const sentMessages = [];
+    const pngBytes = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    const client = {
+        im: {
+            messageResource: {
+                get: async (request) => {
+                    strict_1.default.equal(request.path.message_id, 'msg-image-1');
+                    strict_1.default.equal(request.path.file_key, 'img-key-1');
+                    strict_1.default.equal(request.params.type, 'image');
+                    return {
+                        headers: { 'content-type': 'image/png' },
+                        getReadableStream: () => node_stream_1.Readable.from([pngBytes]),
+                    };
+                },
+            },
+            messageReaction: {
+                create: async () => ({ data: { reaction_id: 'reaction-1' } }),
+            },
+        },
+    };
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            expirePendingPairings: () => { },
+            getAuthorizedUser: () => ({
+                id: 'auth-1',
+                workspace_id: 'default',
+                platform: 'lark',
+                platform_user_id: 'user-1',
+                chat_id: 'chat-1',
+                display_name: 'User',
+                thread_id: 'thread-1',
+            }),
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+            getLatestRunForThread: () => null,
+            clearPlatformThreadMessageId: () => { },
+        },
+        readConfig: async () => ({
+            projects: [{
+                    name: 'default',
+                    root: '/tmp/project',
+                    platforms: [{
+                            type: 'lark',
+                            options: {
+                                app_id: 'app-1',
+                                app_secret: 'secret-1',
+                            },
+                        }],
+                }],
+        }),
+        getWorkspaceRouter: () => ({
+            getThreadSessionKey: (threadId) => `session:${threadId}`,
+            sendThreadMessage: async (threadId, content) => {
+                sentMessages.push({ threadId, content });
+                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.handleMessageEvent('default', {
+        event: {
+            sender: {
+                sender_id: { user_id: 'user-1' },
+            },
+            message: {
+                message_id: 'msg-image-1',
+                message_type: 'image',
+                chat_id: 'chat-1',
+                content: JSON.stringify({ image_key: 'img-key-1' }),
+            },
+        },
+    });
+    strict_1.default.equal(sentMessages.length, 1);
+    strict_1.default.equal(sentMessages[0]?.threadId, 'thread-1');
+    strict_1.default.match(sentMessages[0]?.content?.displayText, /\[User Message\]\n\[Image\]\n\[\/User Message\]/);
+    strict_1.default.deepEqual(sentMessages[0]?.content?.contentParts?.map((part) => part.type), ['text', 'image']);
+    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 message callbacks acknowledge before long thread runs finish', async () => {
+    let registeredHandlers = {};
+    let sentMessages = 0;
+    const logs = [];
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            expirePendingPairings: () => { },
+            getAuthorizedUser: () => ({
+                id: 'auth-1',
+                workspace_id: 'default',
+                platform_user_id: 'user-1',
+                chat_id: 'chat-1',
+                display_name: 'User',
+                thread_id: 'thread-1',
+            }),
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+            getLatestRunForThread: () => null,
+            clearPlatformThreadMessageId: () => { },
+            listPendingPairings: () => [],
+            listAuthorizedUsers: () => [],
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'claudecode', providers: [] },
+                    platforms: [{ type: 'lark', options: { app_id: 'app-1', app_secret: 'secret-1', auto_approve: true } }],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({
+            getThreadSessionKey: (threadId) => `session:${threadId}`,
+            sendThreadMessage: async () => {
+                sentMessages++;
+                return new Promise(() => { });
+            },
+        }),
+        eventBus: { emit: () => { }, on: () => () => { } },
+        log: (message) => logs.push(message),
+    });
+    gateway.larkModulePromise = Promise.resolve({
+        AppType: { SelfBuild: 'self-build' },
+        Domain: { Feishu: 'feishu' },
+        LoggerLevel: { info: 'info' },
+        Client: class {
+        },
+        EventDispatcher: class {
+            register(handlers) {
+                registeredHandlers = handlers;
+            }
+        },
+        WSClient: class {
+            async start() { }
+        },
+    });
+    await gateway.enable('default');
+    const handler = registeredHandlers['im.message.receive_v1'];
+    strict_1.default.equal(typeof handler, 'function');
+    const result = await Promise.race([
+        handler({
+            event: {
+                sender: { sender_id: { user_id: 'user-1' } },
+                message: {
+                    message_id: 'msg-1',
+                    chat_id: 'chat-1',
+                    message_type: 'text',
+                    content: JSON.stringify({ text: 'hi' }),
+                },
+            },
+        }),
+        new Promise((resolve) => setTimeout(() => resolve('timed-out'), 25)),
+    ]);
+    strict_1.default.notEqual(result, 'timed-out');
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    strict_1.default.equal(sentMessages, 1);
+    strict_1.default.ok(logs.some((line) => line.includes('received im.message.receive_v1') &&
+        line.includes('message=msg-1') &&
+        line.includes('type=text') &&
+        line.includes('chat=chat-1') &&
+        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)('ACP skips empty generic running tool updates', () => {
     const appended = [];
     const emitted = [];