@kafca/agentdock 0.1.44 → 0.1.46

package/dist-electron/tests/electron/workspace-task-store.test.js

@@ -10,6 +10,7 @@ const node_path_1 = require("node:path");
 const node_os_1 = require("node:os");
 const local_core_acp_store_js_1 = require("../../services/local-ai-core/src/acp/local-core-acp-store.js");
 const local_core_acp_session_coordinator_js_1 = require("../../services/local-ai-core/src/acp/local-core-acp-session-coordinator.js");
+const local_core_acp_transport_js_1 = require("../../services/local-ai-core/src/acp/local-core-acp-transport.js");
 const local_core_acp_turn_coordinator_js_1 = require("../../services/local-ai-core/src/acp/local-core-acp-turn-coordinator.js");
 const scheduler_service_js_1 = require("../../services/local-ai-core/src/scheduler/scheduler-service.js");
 const lark_schedule_adapter_js_1 = require("../../services/local-ai-core/src/scheduler/lark-schedule-adapter.js");
@@ -40,6 +41,141 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('model providers persist independently from workspace config', () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'model-provider-store-'));
+    try {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        const provider = store.upsertModelProvider({
+            name: 'deepseek',
+            api_key: 'secret',
+            base_url: 'https://api.deepseek.com',
+            model: 'deepseek-v4-flash',
+            env: { CUSTOM_PROVIDER_ENV: '1' },
+        });
+        strict_1.default.equal(provider.id, 'deepseek');
+        strict_1.default.equal(provider.api_key, 'secret');
+        strict_1.default.equal(store.listModelProviders().length, 1);
+        const reopened = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        strict_1.default.equal(reopened.getModelProvider('deepseek')?.model, 'deepseek-v4-flash');
+        reopened.close();
+        store.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('external project and thread mappings persist with isolated workspace paths', () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'external-store-'));
+    try {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        const project = store.upsertExternalProject({
+            userId: 'user-a',
+            externalProjectId: 'project-a',
+            workspaceId: 'external-user-a-project-a',
+            workspacePath: '/data/users/user-a/projects/project-a',
+            displayName: 'Project A',
+            agentType: 'pi',
+            providerId: 'deepseek',
+            metadata: { source: 'external' },
+            createdAt: '2026-05-15T00:00:00.000Z',
+            updatedAt: '2026-05-15T00:00:00.000Z',
+        });
+        const thread = store.createThread(project.workspaceId, 'Thread A', 'pi');
+        store.upsertExternalThread({
+            userId: project.userId,
+            externalProjectId: project.externalProjectId,
+            externalThreadId: 'thread-a',
+            workspaceId: project.workspaceId,
+            threadId: thread.id,
+            workspacePath: '/data/users/user-a/projects/project-a/threads/thread-a/workspace',
+            metadata: { channel: 'api' },
+            createdAt: '2026-05-15T00:00:00.000Z',
+            updatedAt: '2026-05-15T00:00:00.000Z',
+        });
+        store.close();
+        const reopened = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        strict_1.default.equal(reopened.getExternalProject('user-a', 'project-a')?.workspacePath, '/data/users/user-a/projects/project-a');
+        strict_1.default.equal(reopened.getExternalThreadByThreadId(thread.id)?.workspacePath, '/data/users/user-a/projects/project-a/threads/thread-a/workspace');
+        reopened.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('controller migrates embedded project providers into shared provider store', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'model-provider-migration-'));
+    try {
+        const runtime = (0, bootstrap_js_1.bootstrapLocalCoreRuntime)({
+            userDataPath,
+            enableKnowledge: false,
+            log: () => { },
+        });
+        const controller = new local_core_controller_js_1.LocalCoreController(userDataPath, runtime);
+        await controller.saveStructuredConfigFile({
+            projects: [{
+                    name: 'workspace-a',
+                    agent: {
+                        type: 'pi',
+                        options: { work_dir: '/tmp/workspace-a' },
+                        providers: [{
+                                name: 'deepseek-v4-flash',
+                                api_key: 'secret',
+                                base_url: 'https://api.deepseek.com',
+                                model: 'deepseek-v4-flash',
+                            }],
+                    },
+                    platforms: [],
+                }],
+        });
+        const config = await controller.readConfigFile();
+        strict_1.default.equal(config.parsed?.projects?.[0]?.agent.options?.provider_id, 'deepseek');
+        strict_1.default.equal(config.parsed?.projects?.[0]?.agent.providers, undefined);
+        const providers = await controller.listModelProviders();
+        strict_1.default.equal(providers.providers[0]?.id, 'deepseek');
+        strict_1.default.equal(providers.providers[0]?.name, 'deepseek');
+        await controller.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('workspace router resolves projects that select a shared provider', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'workspace-provider-ref-'));
+    try {
+        const runtime = (0, bootstrap_js_1.bootstrapLocalCoreRuntime)({
+            userDataPath,
+            enableKnowledge: false,
+            log: () => { },
+        });
+        const controller = new local_core_controller_js_1.LocalCoreController(userDataPath, runtime);
+        const provider = await controller.createModelProvider({
+            name: 'deepseek',
+            api_key: 'secret',
+            base_url: 'https://api.deepseek.com',
+            model: 'deepseek-v4-flash',
+        });
+        await controller.saveStructuredConfigFile({
+            projects: [{
+                    name: 'workspace-a',
+                    agent: {
+                        type: 'pi',
+                        options: {
+                            work_dir: '/tmp/workspace-a',
+                            provider_id: provider.id,
+                        },
+                    },
+                    platforms: [],
+                }],
+        });
+        const workspaces = await controller.listWorkspaces();
+        strict_1.default.equal(workspaces[0]?.id, 'workspace-a');
+        strict_1.default.equal(workspaces[0]?.agentType, 'pi');
+        await controller.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('scheduler create resolves a Lark delivery route without binding the job to a thread', async () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-binding-route-'));
     try {
@@ -443,6 +579,50 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('ACP runtime PATH includes service-safe user bin directories', () => {
+    const previousHome = process.env.HOME;
+    process.env.HOME = '/home/agentdock-test';
+    try {
+        const path = (0, local_core_acp_session_coordinator_js_1.buildAgentPath)('/usr/bin:/bin', '/opt/agentdock/bin');
+        strict_1.default.equal(path, '/opt/agentdock/bin:/home/agentdock-test/.local/bin:/home/agentdock-test/bin:/usr/bin:/bin');
+    }
+    finally {
+        if (previousHome === undefined) {
+            delete process.env.HOME;
+        }
+        else {
+            process.env.HOME = previousHome;
+        }
+    }
+});
+(0, node_test_1.default)('ACP transport reports missing agent commands without an unhandled process error', async () => {
+    const closed = new Promise((resolve) => {
+        const transport = new local_core_acp_transport_js_1.LocalCoreAcpTransport({
+            log: () => { },
+            onAgentRequest: () => { },
+            onAgentNotification: () => { },
+            onSessionClosed: (_session, error) => {
+                resolve(error);
+            },
+        });
+        transport.spawnSession({
+            threadId: 'thread-missing-command',
+            bridgeSessionKey: 'session:missing-command',
+            config: {
+                workspaceId: 'workspace-a',
+                agentType: 'hermes',
+                command: 'agentdock-command-that-does-not-exist',
+                args: ['acp'],
+                env: {},
+                workDir: (0, node_os_1.tmpdir)(),
+                model: '',
+            },
+            runtimeEnv: {},
+        });
+    });
+    const error = await closed;
+    strict_1.default.equal(error.message, 'ACP agent command not found: agentdock-command-that-does-not-exist');
+});
 (0, node_test_1.default)('ACP scheduled session can override permission mode without changing thread mode', async () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-permission-mode-'));
     try {
@@ -515,6 +695,83 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('ACP sandbox sessions use container workspace cwd', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'sandbox-session-cwd-'));
+    try {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        const thread = store.createThread('workspace-a', 'Thread');
+        let sessionNewParams;
+        const coordinator = new local_core_acp_session_coordinator_js_1.LocalCoreAcpSessionCoordinator({
+            store,
+            transport: {
+                spawnSession(input) {
+                    return {
+                        threadId: input.threadId,
+                        bridgeSessionKey: input.bridgeSessionKey,
+                        closed: false,
+                        sessionId: '',
+                        supportsLoad: false,
+                        pendingPermissionByRun: new Map(),
+                        schedulerJobCreatedByRun: new Map(),
+                        launchPermissionMode: '',
+                    };
+                },
+                initializeSession: async () => { },
+                request: async (_session, method, params) => {
+                    if (method === 'session/new') {
+                        sessionNewParams = params;
+                        return { sessionId: 'session-1' };
+                    }
+                    return {};
+                },
+                closeSession: () => { },
+                closeSessionWithError: () => { },
+                sendRaw: () => true,
+            },
+            runThreadMap: new Map(),
+            emitBridge: () => { },
+        });
+        await coordinator.ensureSession(thread.id, 'session:thread-1', {
+            workspaceId: 'workspace-a',
+            agentType: 'pi',
+            command: process.execPath,
+            args: ['/host/sandbox-stdio-proxy.js'],
+            env: {},
+            workDir: '/host/workspace-a',
+            model: '',
+            sandbox: {
+                enabled: true,
+                provider: 'opensandbox',
+                transport: 'http-ndjson',
+                serverUrl: 'http://127.0.0.1:8080',
+                apiKeyEnv: 'OPEN_SANDBOX_API_KEY',
+                image: 'agentdock/pi-acp:local',
+                acpPort: 8080,
+                entrypoint: ['node', '/opt/agentdock/acp-bridge.mjs'],
+                timeoutSeconds: 600,
+                lifecycle: 'per_thread',
+                idleSeconds: 900,
+                warmPoolSize: 0,
+                cpu: '1000m',
+                memory: '1Gi',
+                userId: 'local',
+                projectId: 'workspace-a',
+                stateScope: 'project',
+                workspaceHostPath: '/host/workspace-a',
+                workspaceMountPath: '/workspace',
+                stateHostPath: '/host/state',
+                stateMountPath: '/agent-state',
+                runtimeCommand: '/usr/local/bin/pi-acp',
+                runtimeArgs: [],
+                runtimeEnv: {},
+            },
+        });
+        strict_1.default.equal(sessionNewParams?.cwd, '/workspace');
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('ACP permission requests honor scheduled session permission override', () => {
     const sentPayloads = [];
     let approvalCreated = false;

package/dist-electron/tests/integration/lark-gateway.test.js

@@ -687,6 +687,65 @@ function findLarkPostMdText(content) {
     strict_1.default.deepEqual(patchedCards.map((card) => card.text), []);
     strict_1.default.ok(!createdCards.some((card) => /处理中|正在思考/.test(card.text)));
 });
+(0, node_test_1.default)('lark gateway records structured error state when startup fails', async () => {
+    const emittedEvents = [];
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            expirePendingPairings: () => { },
+            listPendingPairings: () => [],
+            listAuthorizedUsers: () => [],
+        },
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({}),
+        eventBus: {
+            emit: (event) => emittedEvents.push(event),
+            on: () => () => { },
+        },
+    });
+    gateway.larkModulePromise = Promise.resolve({
+        AppType: { SelfBuild: 'SelfBuild' },
+        Domain: { Feishu: 'Feishu' },
+        LoggerLevel: { info: 'info' },
+        Client: class {
+            request() {
+                return Promise.resolve({ bot: { open_id: 'bot-open-id' } });
+            }
+        },
+        EventDispatcher: class {
+            register() { }
+        },
+        WSClient: class {
+            start() {
+                throw new Error('invalid app credentials');
+            }
+            on() { }
+        },
+    });
+    await gateway.startWorkspace({
+        workspaceId: 'workspace-1',
+        instanceId: 'default',
+        displayName: 'Workspace 1',
+        platformKey: 'lark',
+        appId: 'cli_a1',
+        appSecret: 'secret',
+        encryptKey: '',
+        verificationToken: '',
+        autoApprove: false,
+        cardActionsEnabled: true,
+        groupReplyAll: false,
+        enabled: true,
+        brand: 'lark',
+        project: { name: 'workspace-1' },
+    });
+    const status = gateway.getStatus('workspace-1');
+    strict_1.default.equal(status.status, 'error');
+    strict_1.default.equal(status.connected, false);
+    strict_1.default.equal(status.lastErrorInfo?.code, 'channel_auth_failed');
+    strict_1.default.equal(status.lastErrorInfo?.suggestedAction, 'Check app credentials and restart the Lark gateway.');
+    strict_1.default.match(status.lastError || '', /invalid app credentials/);
+    strict_1.default.ok(status.lastErrorAt);
+    strict_1.default.equal(emittedEvents.some((event) => event.type === 'localcore.error' && event.payload?.scope === 'channel.lark'), true);
+});
 (0, node_test_1.default)('lark permission requests render as clickable card buttons', async () => {
     const createdCards = [];
     const patchedCards = [];
@@ -1424,6 +1483,86 @@ function findLarkPostMdText(content) {
     });
     strict_1.default.equal(sentMessages.length, 0);
 });
+(0, node_test_1.default)('lark post messages from numbered lists are delivered as text', async () => {
+    const sentMessages = [];
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            expirePendingPairings: () => { },
+            getAuthorizedUser: () => ({
+                id: 'auth-1',
+                workspace_id: 'project-1',
+                platform: 'lark:lark-1',
+                platform_user_id: 'user-1',
+                chat_id: 'chat-1',
+                display_name: 'User',
+                thread_id: 'thread-1',
+            }),
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'project-1',
+                platform: 'lark:lark-1',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+            getLatestRunForThread: () => null,
+            clearPlatformThreadMessageId: () => { },
+        },
+        readConfig: async () => ({ projects: [] }),
+        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('project-1::lark-1', {
+        workspaceId: 'project-1',
+        instanceId: 'lark-1',
+        platformKey: 'lark:lark-1',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        client: {
+            im: {
+                messageReaction: {
+                    create: async () => ({ data: { reaction_id: 'reaction-1' } }),
+                },
+            },
+        },
+    });
+    await internals.handleMessageEvent('project-1', 'lark-1', 'lark:lark-1', {
+        event: {
+            sender: {
+                sender_id: { user_id: 'user-1' },
+            },
+            message: {
+                message_id: 'msg-post-numbered-list',
+                message_type: 'post',
+                chat_id: 'chat-1',
+                chat_type: 'p2p',
+                content: JSON.stringify({
+                    title: '',
+                    content: [
+                        [
+                            { tag: 'text', text: '1. hi' },
+                        ],
+                        [
+                            { tag: 'text', text: '2. hello' },
+                        ],
+                    ],
+                }),
+            },
+        },
+    });
+    strict_1.default.equal(sentMessages.length, 1);
+    strict_1.default.equal(sentMessages[0]?.threadId, 'thread-1');
+    strict_1.default.match(sentMessages[0]?.content, /\[User Message\]\n1\. hi\n2\. hello\n\[\/User Message\]/);
+});
 (0, node_test_1.default)('lark inbound messages create a chat binding when an authorized user has an old direct thread', async () => {
     const bindings = [];
     const createdThreads = [];