@kafca/agentdock 0.1.22 → 0.1.24

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

@@ -18,6 +18,7 @@ const local_core_weixin_gateway_js_1 = require("../services/local-ai-core/src/ch
 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 = [];
@@ -779,6 +927,116 @@ const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/loc
     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 = [];
@@ -1044,6 +1302,102 @@ 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 file messages are downloaded and forwarded as generic channel file parts', async () => {
+    const sentMessages = [];
+    const fileBytes = Buffer.from('file content');
+    const client = {
+        im: {
+            messageResource: {
+                get: async (request) => {
+                    strict_1.default.equal(request.path.message_id, 'msg-file-in-1');
+                    strict_1.default.equal(request.path.file_key, 'file-key-in-1');
+                    strict_1.default.equal(request.params.type, 'file');
+                    return {
+                        headers: { 'content-type': 'application/pdf' },
+                        getReadableStream: () => node_stream_1.Readable.from([fileBytes]),
+                    };
+                },
+            },
+            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-file-in-1',
+                message_type: 'file',
+                chat_id: 'chat-1',
+                content: JSON.stringify({ file_key: 'file-key-in-1', file_name: 'report.pdf' }),
+            },
+        },
+    });
+    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\[File: report\.pdf\]\n\[\/User Message\]/);
+    strict_1.default.deepEqual(sentMessages[0]?.content?.contentParts?.map((part) => part.type), ['text', 'file']);
+    strict_1.default.equal(sentMessages[0]?.content?.contentParts?.[1]?.mimeType, 'application/pdf');
+    strict_1.default.equal(sentMessages[0]?.content?.contentParts?.[1]?.data, fileBytes.toString('base64'));
+    strict_1.default.equal(sentMessages[0]?.content?.contentParts?.[1]?.fileName, 'report.pdf');
+});
 (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 {
@@ -1310,6 +1664,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 = [];
@@ -1696,6 +2124,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);
@@ -1764,6 +2194,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();
@@ -1820,6 +2421,33 @@ const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/loc
     strict_1.default.equal(sentThreadMessages.length, 1);
     strict_1.default.match(sentThreadMessages[0] || '', /hello/);
 });
+(0, node_test_1.default)('weixin downloaded file attachment becomes a structured file content part', () => {
+    const part = (0, local_core_weixin_gateway_js_1.createWeixinAttachmentContentPart)({
+        path: '/tmp/report.pdf',
+        kind: 'file',
+        name: 'report.pdf',
+    });
+    strict_1.default.deepEqual(part, {
+        type: 'file',
+        path: '/tmp/report.pdf',
+        fileName: 'report.pdf',
+    });
+});
+(0, node_test_1.default)('weixin downloaded image attachment keeps image data content part', () => {
+    const part = (0, local_core_weixin_gateway_js_1.createWeixinAttachmentContentPart)({
+        path: '/tmp/image.png',
+        kind: 'image',
+        name: 'image.png',
+        data: 'aW1n',
+        mimeType: 'image/png',
+    });
+    strict_1.default.deepEqual(part, {
+        type: 'image',
+        data: 'aW1n',
+        mimeType: 'image/png',
+        fileName: 'image.png',
+    });
+});
 (0, node_test_1.default)('weixin bridge skips duplicate rendered replies', async () => {
     const originalFetch = globalThis.fetch;
     const sentBodies = [];