@kafca/agentdock 0.1.36 → 0.1.38

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_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");
 const bootstrap_js_1 = require("../../services/local-ai-core/src/kernel/bootstrap.js");
@@ -165,10 +166,13 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
             enabled: true,
         });
         let sentThreadId = '';
-        let deliveredRoute;
+        let registeredBridge;
+        const bridgeEvents = [];
+        let unregisteredBridge = false;
         const adapter = new lark_schedule_adapter_js_1.LarkScheduleAdapter({
             store,
             getWorkspaceRouter: () => ({
+                getThreadSessionKey: (threadId) => `session:${threadId}`,
                 getThread: async (threadId) => ({
                     id: threadId,
                     workspaceId: 'workspace-a',
@@ -191,23 +195,38 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
                 },
             }),
             getChannelRuntime: () => ({
-                muteThreadBridge: () => { },
-                unmuteThreadBridge: () => { },
-                sendScheduledMessage: async (_workspaceId, route) => {
-                    deliveredRoute = route;
-                    return 'platform-message-1';
+                onBridgeEvent: async (event) => {
+                    bridgeEvents.push(event);
+                },
+                registerScheduledThreadBridge: (input) => {
+                    registeredBridge = input;
+                    return () => {
+                        unregisteredBridge = true;
+                    };
+                },
+                sendScheduledMessage: async () => {
+                    throw new Error('scheduled Lark replies should be delivered through bridge events');
                 },
             }),
         });
         const result = await adapter.execute({ job, triggeredAt: now });
         strict_1.default.equal(sentThreadId, latestThread.id);
         strict_1.default.equal(result.threadId, latestThread.id);
-        strict_1.default.equal(result.platformMessageId, 'platform-message-1');
-        strict_1.default.deepEqual(deliveredRoute, {
-            type: 'channel.chat',
-            channelId: 'chat-1',
-            participantId: 'user-1',
+        strict_1.default.equal('platformMessageId' in result, false);
+        strict_1.default.deepEqual(registeredBridge, {
+            workspaceId: 'workspace-a',
+            platform: 'lark',
+            route: { type: 'channel.chat', channelId: 'chat-1', participantId: 'user-1', threadId: oldThread.id },
+            threadId: latestThread.id,
+            sessionKey: `session:${latestThread.id}`,
+        });
+        strict_1.default.deepEqual(bridgeEvents[0], {
+            type: 'status',
+            sessionKey: `session:${latestThread.id}`,
+            bridgeKind: 'status',
+            content: '⏰ bound lark task',
         });
+        strict_1.default.equal(unregisteredBridge, true);
         store.close();
     }
     finally {
@@ -247,12 +266,14 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
             store,
             getWorkspaceRouter: () => workspaceRouter,
             getChannelRuntime: () => ({
-                muteThreadBridge: () => { },
-                unmuteThreadBridge: () => { },
-                sendScheduledMessage: async () => 'platform-message-1',
+                registerScheduledThreadBridge: () => () => { },
+                sendScheduledMessage: async () => {
+                    throw new Error('scheduled Lark replies should be delivered through bridge events');
+                },
             }),
         });
         workspaceRouter = {
+            getThreadSessionKey: (threadId) => `session:${threadId}`,
             getThread: async (threadId) => ({
                 id: threadId,
                 workspaceId: 'workspace-a',
@@ -277,7 +298,7 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
         const result = await adapter.execute({ job, triggeredAt: now });
         strict_1.default.equal(sentThreadId, thread.id);
         strict_1.default.equal(result.threadId, thread.id);
-        strict_1.default.equal(result.platformMessageId, 'platform-message-1');
+        strict_1.default.equal('platformMessageId' in result, false);
         store.close();
     }
     finally {
@@ -311,10 +332,11 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
             description: 'bound lark task',
             enabled: true,
         });
-        let deliveredRoute;
+        let registeredBridge;
         const adapter = new lark_schedule_adapter_js_1.LarkScheduleAdapter({
             store,
             getWorkspaceRouter: () => ({
+                getThreadSessionKey: (threadId) => `session:${threadId}`,
                 getThread: async (threadId) => ({
                     id: threadId,
                     workspaceId: 'workspace-a',
@@ -340,22 +362,24 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
                 },
             }),
             getChannelRuntime: () => ({
-                muteThreadBridge: () => { },
-                unmuteThreadBridge: () => { },
-                sendScheduledMessage: async (_workspaceId, route) => {
-                    deliveredRoute = route;
-                    return 'platform-message-1';
+                registerScheduledThreadBridge: (input) => {
+                    registeredBridge = input;
+                    return () => { };
+                },
+                sendScheduledMessage: async () => {
+                    throw new Error('scheduled Lark replies should be delivered through bridge events');
                 },
             }),
         });
         const result = await adapter.execute({ job, triggeredAt: now });
         strict_1.default.equal(result.threadId, thread.id);
-        strict_1.default.equal(result.platformMessageId, 'platform-message-1');
-        strict_1.default.deepEqual(deliveredRoute, {
-            type: 'channel.chat',
-            channelId: 'chat-1',
-            instanceId: 'lark-1',
-            participantId: 'user-1',
+        strict_1.default.equal('platformMessageId' in result, false);
+        strict_1.default.deepEqual(registeredBridge, {
+            workspaceId: 'workspace-a',
+            platform: 'lark:lark-1',
+            route: { type: 'channel.chat', channelId: 'chat-1', participantId: 'user-1' },
+            threadId: thread.id,
+            sessionKey: `session:${thread.id}`,
         });
         store.close();
     }
@@ -491,6 +515,59 @@ 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 permission requests honor scheduled session permission override', () => {
+    const sentPayloads = [];
+    let approvalCreated = false;
+    let awaitingInput = false;
+    const coordinator = new local_core_acp_turn_coordinator_js_1.LocalCoreAcpTurnCoordinator({
+        emitBridge: () => { },
+        appendMessage: () => { },
+        updateRunStatus: () => {
+            awaitingInput = true;
+        },
+        createApprovalRequest: () => {
+            approvalCreated = true;
+            return 'approval-1';
+        },
+        getThreadAgentMode: () => 'default',
+        sendRaw: (_session, payload) => {
+            sentPayloads.push(payload);
+            return true;
+        },
+    });
+    coordinator.handleAgentRequest({
+        threadId: 'thread-1',
+        bridgeSessionKey: 'bridge-1',
+        currentRunId: 'run-1',
+        currentTurn: null,
+        pendingPermissionByRun: new Map(),
+        schedulerJobCreatedByRun: new Map(),
+        launchPermissionMode: 'bypassPermissions',
+    }, {
+        jsonrpc: '2.0',
+        id: 42,
+        method: 'session/request_permission',
+        params: {
+            toolCall: { title: 'Write AI早报/AI早报-2026-05-08.md' },
+            options: [
+                { optionId: 'deny', name: 'Deny', kind: 'deny' },
+                { optionId: 'allow', name: 'Allow', kind: 'allow' },
+            ],
+        },
+    });
+    strict_1.default.equal(approvalCreated, false);
+    strict_1.default.equal(awaitingInput, false);
+    strict_1.default.deepEqual(sentPayloads[0], {
+        jsonrpc: '2.0',
+        id: 42,
+        result: {
+            outcome: {
+                outcome: 'selected',
+                optionId: 'allow',
+            },
+        },
+    });
+});
 (0, node_test_1.default)('scheduler uses short ids for new jobs and resolves legacy full ids by short id', () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-id-store-'));
     try {
@@ -537,6 +614,78 @@ 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)('scheduler dispatches due jobs without waiting for long-running jobs', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-dispatch-'));
+    try {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        store.createScheduledJob({
+            workspaceId: 'workspace-a',
+            platform: 'local',
+            route: { type: 'local.thread', channelId: 'workspace-a', threadId: 'thread-1' },
+            executionMode: 'side-thread',
+            triggerType: 'cron',
+            cronExpr: '* * * * *',
+            promptTemplate: 'slow',
+            description: 'slow job',
+            enabled: true,
+        });
+        store.createScheduledJob({
+            workspaceId: 'workspace-a',
+            platform: 'local',
+            route: { type: 'local.thread', channelId: 'workspace-a', threadId: 'thread-2' },
+            executionMode: 'side-thread',
+            triggerType: 'cron',
+            cronExpr: '* * * * *',
+            promptTemplate: 'fast',
+            description: 'fast job',
+            enabled: true,
+        });
+        let releaseSlow;
+        const slowDone = new Promise((resolve) => {
+            releaseSlow = resolve;
+        });
+        const started = [];
+        let slowJobId = '';
+        const scheduler = new scheduler_service_js_1.SchedulerService({
+            store,
+            triggers: [{
+                    triggerTypes: ['cron'],
+                    supports: () => true,
+                    isDue: () => true,
+                }],
+            executors: [{
+                    deliveryTargets: ['local'],
+                    supports: () => true,
+                    execute: async ({ job }) => {
+                        const isFirstStartedJob = started.length === 0;
+                        started.push(job.id);
+                        if (isFirstStartedJob) {
+                            slowJobId = job.id;
+                            await slowDone;
+                        }
+                        return {
+                            threadId: String(job.route.threadId || job.id),
+                            runId: `run:${job.id}`,
+                        };
+                    },
+                }],
+            eventBus: { emit: () => { }, on: () => () => { } },
+        });
+        await scheduler.tick();
+        await new Promise((resolve) => setImmediate(resolve));
+        strict_1.default.equal(started.length, 2);
+        const fastJobId = started.find((id) => id !== slowJobId);
+        strict_1.default.equal(store.listScheduledJobRuns(slowJobId)[0]?.status, 'running');
+        strict_1.default.equal(store.listScheduledJobRuns(fastJobId)[0]?.status, 'succeeded');
+        releaseSlow();
+        await new Promise((resolve) => setImmediate(resolve));
+        strict_1.default.equal(store.listScheduledJobRuns(slowJobId)[0]?.status, 'succeeded');
+        store.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('scheduled jobs normalize enum-like input before persistence', () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-enum-store-'));
     try {
@@ -633,10 +782,21 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
             description: 'daily ping',
             enabled: true,
         });
-        const run = store.createScheduledJobRun(job.id, 'complete');
+        const run = store.createScheduledJobRun(job.id, 'complete', {
+            deliveryMode: 'bridge-stream',
+            deliveryStatus: 'streaming',
+            platformMessageIds: ['msg-1', 'msg-2'],
+            lastBridgeEventAt: '2026-04-22T06:00:03.000Z',
+        });
         strict_1.default.equal(run.status, 'succeeded');
+        strict_1.default.equal(run.deliveryMode, 'bridge-stream');
+        strict_1.default.equal(run.deliveryStatus, 'streaming');
+        strict_1.default.deepEqual(run.platformMessageIds, ['msg-1', 'msg-2']);
+        strict_1.default.equal(run.lastBridgeEventAt, '2026-04-22T06:00:03.000Z');
         const skipped = store.updateScheduledJobRun(run.id, { status: 'cancelled' });
         strict_1.default.equal(skipped.status, 'skipped');
+        strict_1.default.equal(skipped.deliveryMode, 'bridge-stream');
+        strict_1.default.deepEqual(skipped.platformMessageIds, ['msg-1', 'msg-2']);
         strict_1.default.equal(store.getScheduledJob(job.id)?.lastStatus, 'skipped');
         store.close();
     }