@kafca/agentdock 0.1.43 → 0.1.45

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/channel-gateways.test.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+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");
+(0, node_test_1.default)('channel gateways ignore unowned bridge events without route miss log noise', async () => {
+    const logs = [];
+    const commonOptions = {
+        store: {},
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+        log: (line) => logs.push(line),
+    };
+    const larkGateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway(commonOptions);
+    const weixinGateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway(commonOptions);
+    await larkGateway.onBridgeEvent({
+        type: 'update_message',
+        sessionKey: 'localcore-acp:project-1:thread-1',
+        content: 'stream chunk',
+    });
+    await weixinGateway.onBridgeEvent({
+        type: 'update_message',
+        sessionKey: 'localcore-acp:project-1:thread-1',
+        content: 'stream chunk',
+    });
+    strict_1.default.deepEqual(logs, []);
+});