@kafca/agentdock 0.1.44 → 0.1.46

package/dist-electron/tests/electron/plugin-kernel.test.js

@@ -83,6 +83,49 @@ function plugin(id, dependsOn = []) {
         },
     };
 }
+async function invokeServer(server, method, url, inputBody) {
+    const requestBody = inputBody === undefined ? '' : JSON.stringify(inputBody);
+    const req = Object.assign(new node_events_1.EventEmitter(), {
+        method,
+        url,
+        headers: {},
+        async *[Symbol.asyncIterator]() {
+            if (requestBody) {
+                yield Buffer.from(requestBody);
+            }
+        },
+    });
+    let body = '';
+    const headers = new Map();
+    const res = Object.assign(new node_events_1.EventEmitter(), {
+        statusCode: 200,
+        setHeader(name, value) {
+            headers.set(name, value);
+        },
+        writeHead(statusCode, nextHeaders) {
+            this.statusCode = statusCode;
+            for (const [name, value] of Object.entries(nextHeaders)) {
+                headers.set(name, value);
+            }
+        },
+        write(chunk) {
+            body += chunk;
+            return true;
+        },
+        end(chunk) {
+            if (chunk) {
+                body += chunk;
+            }
+            res.emit('finish');
+        },
+    });
+    await server.handleRequest(req, res);
+    return {
+        statusCode: res.statusCode,
+        headers,
+        body: body ? JSON.parse(body) : null,
+    };
+}
 (0, node_test_1.default)('bootstrapLocalCoreKernel exposes the static built-in capability snapshot', () => {
     const kernel = (0, bootstrap_js_1.bootstrapLocalCoreKernel)();
     strict_1.default.deepEqual(kernel.getCapabilitySnapshot(), {
@@ -464,6 +507,45 @@ model = "deepseek-v4-flash"
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('pi agent runtime normalizes DeepSeek provider when provider name is the model id', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentdock-kernel-'));
+    try {
+        const runtime = (0, bootstrap_js_2.bootstrapLocalCoreRuntime)({
+            userDataPath,
+            enableKnowledge: false,
+        });
+        await runtime.state.saveRawConfigFile(`
+[[projects]]
+name = "deepseek-model-name-workspace"
+
+[projects.agent]
+type = "pi"
+
+[[projects.agent.providers]]
+name = "deepseek-v4-flash"
+api_key = "test-deepseek-key"
+base_url = "https://api.deepseek.com"
+model = "deepseek-v4-flash"
+`);
+        const configState = await runtime.state.readConfigFile();
+        const project = configState.parsed?.projects?.find((entry) => entry.name === 'deepseek-model-name-workspace');
+        const piRuntime = runtime.agentRuntimes.find((entry) => entry.agentType === 'pi');
+        const route = project ? piRuntime?.createRoute(configState, project) : null;
+        const piAgentDir = route?.config.env.PI_CODING_AGENT_DIR || '';
+        strict_1.default.equal(route?.config.env.DEEPSEEK_API_KEY, 'test-deepseek-key');
+        strict_1.default.deepEqual(JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(piAgentDir, 'auth.json'), 'utf8')), {
+            deepseek: { type: 'api_key', key: 'test-deepseek-key' },
+        });
+        strict_1.default.deepEqual(JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(piAgentDir, 'settings.json'), 'utf8')), {
+            defaultProvider: 'deepseek',
+            defaultModel: 'deepseek-v4-flash',
+            quietStartup: true,
+        });
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('runtime bootstrap knowledge capabilities come from the selected provider plugin', () => {
     const enabledUserDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentdock-kernel-'));
     const disabledUserDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentdock-kernel-'));
@@ -870,24 +952,149 @@ model = "deepseek-v4-flash"
         },
     });
     const server = new server_js_1.LocalAiCoreServer(bindings, { port: 0 });
-    await server.start();
-    try {
-        const address = server.server.address();
-        const baseUrl = `http://127.0.0.1:${address.port}/api/local/v1`;
-        const qrResponse = await fetch(`${baseUrl}/platforms/slack/workspace-1/qrcode?instance_id=bot-1`, { method: 'POST' });
-        const qrBody = await qrResponse.json();
-        strict_1.default.equal(qrBody.data.ticket, 'ticket-1');
-        const statusResponse = await fetch(`${baseUrl}/platforms/slack/workspace-1/qrcode/status?ticket=ticket-1&instance_id=bot-1`);
-        const statusBody = await statusResponse.json();
-        strict_1.default.equal(statusBody.data.status, 'signed');
-        strict_1.default.deepEqual(calls, [
-            'get:slack:workspace-1:bot-1',
-            'check:slack:workspace-1:ticket-1:bot-1',
-        ]);
-    }
-    finally {
-        await server.stop();
-    }
+    const qrResponse = await invokeServer(server, 'POST', '/api/local/v1/platforms/slack/workspace-1/qrcode?instance_id=bot-1');
+    strict_1.default.equal(qrResponse.body.data.ticket, 'ticket-1');
+    const statusResponse = await invokeServer(server, 'GET', '/api/local/v1/platforms/slack/workspace-1/qrcode/status?ticket=ticket-1&instance_id=bot-1');
+    strict_1.default.equal(statusResponse.body.data.status, 'signed');
+    strict_1.default.deepEqual(calls, [
+        'get:slack:workspace-1:bot-1',
+        'check:slack:workspace-1:ticket-1:bot-1',
+    ]);
+});
+(0, node_test_1.default)('server unknown routes return structured error responses', async () => {
+    const bindings = new node_events_1.EventEmitter();
+    const server = new server_js_1.LocalAiCoreServer(bindings, { port: 0 });
+    const response = await invokeServer(server, 'GET', '/api/local/v1/not-found');
+    strict_1.default.equal(response.statusCode, 404);
+    strict_1.default.equal(response.body.ok, false);
+    strict_1.default.equal(response.body.code, 'internal_error');
+    strict_1.default.match(response.body.error, /Unknown route/);
+    strict_1.default.equal(response.body.errorInfo?.severity, 'error');
+});
+(0, node_test_1.default)('server diagnostics routes dispatch through generic bindings', async () => {
+    const calls = [];
+    const bindings = Object.assign(new node_events_1.EventEmitter(), {
+        listDiagnosticErrors: async () => {
+            calls.push('errors');
+            return [{
+                    key: 'channel.weixin:channel_session_expired:workspace-1',
+                    count: 2,
+                    firstSeenAt: '2026-05-12T00:00:00.000Z',
+                    lastSeenAt: '2026-05-12T00:05:00.000Z',
+                    errorInfo: {
+                        code: 'channel_session_expired',
+                        message: 'WeChat login expired.',
+                        userMessage: 'Channel login has expired.',
+                        severity: 'error',
+                        retryable: false,
+                        suggestedAction: 'Reconnect the channel.',
+                    },
+                }];
+        },
+        runDiagnosticsDoctor: async () => {
+            calls.push('doctor');
+            return {
+                status: 'warn',
+                checkedAt: '2026-05-12T00:00:00.000Z',
+                checks: [
+                    { id: 'config', label: 'Configuration', status: 'pass', summary: 'ok' },
+                ],
+            };
+        },
+        runDeploymentDiagnostics: async () => {
+            calls.push('deployment');
+            return {
+                status: 'pass',
+                checkedAt: '2026-05-14T00:00:00.000Z',
+                checks: [
+                    { id: 'deployment.profile', label: 'Deployment profile', status: 'pass', summary: 'ok' },
+                ],
+            };
+        },
+    });
+    const server = new server_js_1.LocalAiCoreServer(bindings, { port: 0 });
+    const errorsResponse = await invokeServer(server, 'GET', '/api/local/v1/diagnostics/errors');
+    const doctorResponse = await invokeServer(server, 'POST', '/api/local/v1/diagnostics/doctor');
+    const deploymentResponse = await invokeServer(server, 'POST', '/api/local/v1/diagnostics/deployment');
+    strict_1.default.equal(errorsResponse.body.data.errors[0].errorInfo.code, 'channel_session_expired');
+    strict_1.default.equal(doctorResponse.body.data.status, 'warn');
+    strict_1.default.equal(deploymentResponse.body.data.status, 'pass');
+    strict_1.default.deepEqual(calls, ['errors', 'doctor', 'deployment']);
+});
+(0, node_test_1.default)('server OpenAI-compatible chat route maps metadata to sandbox yolo external run', async () => {
+    let externalInput;
+    const bindings = Object.assign(new node_events_1.EventEmitter(), {
+        createExternalRun: async (input) => {
+            externalInput = input;
+            return {
+                project: {},
+                thread: {},
+                workspace_id: 'external-user-project',
+                thread_id: 'thread-1',
+                run_id: 'run-1',
+                task_id: 'task-1',
+                events_url: '/api/local/v1/external/runs/run-1/events',
+            };
+        },
+        getExternalRunSnapshot: async () => ({
+            runId: 'run-1',
+            task: {
+                taskId: 'task-1',
+                workspaceId: 'external-user-project',
+                runtimeId: 'pi',
+                threadId: 'thread-1',
+                runId: 'run-1',
+                title: 'Task',
+                status: 'completed',
+                createdAt: '2026-05-15T00:00:00.000Z',
+                updatedAt: '2026-05-15T00:00:02.000Z',
+                startedAt: '2026-05-15T00:00:01.000Z',
+                timeline: [],
+                logs: [],
+                artifacts: [],
+                approvalIds: [],
+            },
+            thread: {
+                id: 'thread-1',
+                workspaceId: 'external-user-project',
+                title: 'Thread',
+                createdAt: '2026-05-15T00:00:00.000Z',
+                updatedAt: '2026-05-15T00:00:02.000Z',
+                messages: [{
+                        id: 'message-1',
+                        role: 'assistant',
+                        content: 'final answer',
+                        timestamp: '2026-05-15T00:00:02.000Z',
+                        kind: 'final',
+                    }],
+            },
+        }),
+    });
+    const server = new server_js_1.LocalAiCoreServer(bindings, { port: 0 });
+    const response = await invokeServer(server, 'POST', '/api/local/v1/openai/chat/completions', {
+        model: 'model-1',
+        stream: false,
+        metadata: {
+            user_id: 'user-1',
+            project_id: 'project-1',
+            thread_id: 'thread-1',
+            agent_type: 'pi',
+        },
+        messages: [
+            { role: 'system', content: 'Be concise.' },
+            { role: 'user', content: 'Hello' },
+        ],
+    });
+    strict_1.default.equal(response.statusCode, 200);
+    strict_1.default.equal(response.body.object, 'chat.completion');
+    strict_1.default.equal(response.body.choices[0].message.content, 'final answer');
+    strict_1.default.equal(externalInput.user_id, 'user-1');
+    strict_1.default.equal(externalInput.external_project_id, 'project-1');
+    strict_1.default.equal(externalInput.external_thread_id, 'thread-1');
+    strict_1.default.equal(externalInput.permission_mode, 'bypassPermissions');
+    strict_1.default.equal(externalInput.runtime_env.AGENTDOCK_OPENAI_COMPAT, '1');
+    strict_1.default.match(externalInput.prompt, /\[system\]\nBe concise\./);
+    strict_1.default.match(externalInput.prompt, /Hello/);
 });
 (0, node_test_1.default)('channel and scheduler capabilities use registry targets instead of Lark-specific routing', () => {
     const registry = new plugin_registry_js_1.LocalCorePluginRegistry();

package/dist-electron/tests/electron/runtime-detection-service.test.js

@@ -50,6 +50,26 @@ const runtime_detection_service_js_1 = require("../../services/local-ai-core/src
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('runtime detection service does not probe runtimes on startup', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-detection-service-startup-'));
+    try {
+        let calls = 0;
+        const service = new runtime_detection_service_js_1.RuntimeDetectionService({
+            userDataPath,
+            readConfig: async () => null,
+            detect: () => {
+                calls += 1;
+                return [runtimeResult({ version: '9.9.9' })];
+            },
+        });
+        await service.refreshOnStartup();
+        strict_1.default.equal(calls, 0);
+        strict_1.default.equal(service.list('opencode')[0]?.status, 'unknown');
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('runtime detection service ignores corrupted persisted state', () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-detection-service-corrupt-'));
     try {
@@ -71,30 +91,59 @@ const runtime_detection_service_js_1 = require("../../services/local-ai-core/src
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-detection-service-events-'));
     try {
         const events = [];
+        const runtimeIds = [];
         const service = new runtime_detection_service_js_1.RuntimeDetectionService({
             userDataPath,
             readConfig: async () => null,
-            detect: () => [
-                runtimeResult({ runtimeId: 'opencode', agentType: 'opencode' }),
-                runtimeResult({ runtimeId: 'codex', agentType: 'codex' }),
-            ],
+            detect: (options) => {
+                runtimeIds.push(options.runtimeId);
+                return [runtimeResult({ runtimeId: 'codex', agentType: 'codex' })];
+            },
             emit: (event) => {
                 events.push(event.type);
             },
         });
         const refreshed = await service.refresh('codex');
         strict_1.default.deepEqual(refreshed.map((runtime) => runtime.runtimeId), ['codex']);
+        strict_1.default.deepEqual(runtimeIds, ['codex']);
+        strict_1.default.equal(service.list('opencode')[0]?.status, 'unknown');
+        strict_1.default.equal(service.list('codex')[0]?.status, 'installed');
         strict_1.default.deepEqual(events, [
             'runtime.detect.started',
             'runtime.detect.completed',
             'runtime.status.changed',
-            'runtime.status.changed',
         ]);
     }
     finally {
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('runtime detection service records runtime launch errors as failed readiness', () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-detection-service-launch-error-'));
+    try {
+        const service = new runtime_detection_service_js_1.RuntimeDetectionService({
+            userDataPath,
+            readConfig: async () => null,
+            detect: () => [runtimeResult({ runtimeId: 'hermes', agentType: 'hermes', displayName: 'Hermes' })],
+        });
+        service.recordLaunchError('hermes', {
+            code: 'runtime_not_found',
+            message: 'ACP agent command not found: hermes',
+            userMessage: 'Hermes is not installed or is not available on PATH.',
+            severity: 'error',
+            retryable: false,
+            suggestedAction: 'Install Hermes or update the service PATH.',
+        });
+        const runtime = service.list('hermes')[0];
+        strict_1.default.equal(runtime?.status, 'error');
+        strict_1.default.equal(runtime?.readiness, 'failed');
+        strict_1.default.equal(runtime?.lastLaunchError?.code, 'runtime_not_found');
+        strict_1.default.equal(runtime?.recommendedActions[0]?.label, 'Fix runtime launch');
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 function runtimeResult(input = {}) {
     return {
         agentType: input.agentType || 'opencode',
@@ -112,5 +161,8 @@ function runtimeResult(input = {}) {
         recommendedActions: input.recommendedActions || [],
         source: input.source || 'path',
         error: input.error,
+        readiness: input.readiness,
+        lastLaunchError: input.lastLaunchError,
+        lastCheckedAt: input.lastCheckedAt,
     };
 }