@kafca/agentdock 0.1.36 → 0.1.38

package/dist-electron/services/local-ai-core/src/scheduler/lark-execution-policies.js

@@ -1,66 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLarkExecutionPolicy = createLarkExecutionPolicy;
+const channel_execution_policy_js_1 = require("./channel-execution-policy.js");
 function createLarkExecutionPolicy(job, options, resolveSameThread) {
-    if (job.executionMode === 'side-thread') {
-        return new LarkSideThreadExecutionPolicy(options);
-    }
-    return new LarkSameThreadExecutionPolicy(options, resolveSameThread);
-}
-class LarkSameThreadExecutionPolicy {
-    options;
-    resolveSameThread;
-    constructor(options, resolveSameThread) {
-        this.options = options;
-        this.resolveSameThread = resolveSameThread;
-    }
-    async resolveTarget(job) {
-        return {
-            kind: 'thread',
-            threadId: await this.resolveSameThread(job),
-            workspaceId: job.workspaceId,
-            platform: job.platform,
-            route: job.route,
-        };
-    }
-    beforeExecute(target) {
-        this.options.getChannelRuntime().muteThreadBridge?.(target.threadId);
-    }
-    afterExecute(target) {
-        this.options.getChannelRuntime().unmuteThreadBridge?.(target.threadId);
-    }
-}
-class LarkSideThreadExecutionPolicy {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    async resolveTarget(job) {
-        const title = `[Scheduled] ${job.description || job.id}`;
-        const existing = (await this.options.workspaceRouter.listThreads(job.workspaceId))
-            .find((thread) => thread.title === title);
-        if (existing) {
-            return {
-                kind: 'thread',
-                threadId: existing.id,
-                workspaceId: job.workspaceId,
-                platform: job.platform,
-                route: job.route,
-            };
-        }
-        const created = await this.options.workspaceRouter.createThread(job.workspaceId, title);
-        return {
-            kind: 'thread',
-            threadId: created.id,
-            workspaceId: job.workspaceId,
-            platform: job.platform,
-            route: job.route,
-        };
-    }
-    beforeExecute(target) {
-        this.options.getChannelRuntime().muteThreadBridge?.(target.threadId);
-    }
-    afterExecute(target) {
-        this.options.getChannelRuntime().unmuteThreadBridge?.(target.threadId);
-    }
+    return (0, channel_execution_policy_js_1.createChannelExecutionPolicy)(job, options, {
+        platformBase: 'lark',
+        resolveSameThread,
+        sideThreadTitle: (nextJob) => `[Scheduled:Lark] ${nextJob.description || nextJob.id}`,
+        legacySideThreadTitles: (nextJob) => [`[Scheduled] ${nextJob.description || nextJob.id}`],
+    });
 }

package/dist-electron/services/local-ai-core/src/scheduler/lark-schedule-adapter.js

@@ -26,22 +26,13 @@ class LarkScheduleAdapter {
             getChannelRuntime: this.options.getChannelRuntime,
         }, (nextJob) => this.resolveThread(nextJob));
         const execution = await this.executor.execute(job, job.promptTemplate, executionPolicy);
-        let platformMessageId = '';
-        if (execution.replyText) {
-            const channelRuntime = this.options.getChannelRuntime();
-            if (!channelRuntime.sendScheduledMessage) {
-                throw new Error('Lark channel runtime does not support scheduled delivery.');
-            }
-            platformMessageId = await channelRuntime.sendScheduledMessage(job.workspaceId, (0, scheduled_job_route_js_1.routeWithPlatformInstance)((0, scheduled_job_route_js_1.withoutThreadRoute)(job.route), job.platform), execution.replyText);
-            if (!platformMessageId) {
-                throw new Error('Lark gateway did not return a message id for scheduled delivery.');
-            }
-        }
         return {
             threadId: execution.threadId,
             runId: execution.runId,
             replyText: execution.replyText,
-            platformMessageId: platformMessageId || undefined,
+            deliveryMode: 'bridge-stream',
+            deliveryStatus: 'succeeded',
+            lastBridgeEventAt: new Date().toISOString(),
         };
     }
     async resolveThread(job) {

package/dist-electron/services/local-ai-core/src/scheduler/local-schedule-adapter.js

@@ -1,34 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalScheduleAdapter = void 0;
-const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'interrupted']);
-const SCHEDULED_RUN_PERMISSION_MODE = 'bypassPermissions';
+const scheduled_conversation_executor_js_1 = require("./scheduled-conversation-executor.js");
 class LocalScheduleAdapter {
     options;
+    executor;
     deliveryTargets = ['local'];
     constructor(options) {
         this.options = options;
+        this.executor = new scheduled_conversation_executor_js_1.ScheduledConversationExecutor({
+            store: options.store,
+            getWorkspaceRouter: options.getWorkspaceRouter,
+        });
     }
     supports(job) {
         return job.platform === 'local' && (job.route.type === 'local.thread' || job.route.type === 'thread');
     }
     async execute(context) {
         const { job } = context;
-        const workspaceRouter = this.options.getWorkspaceRouter();
-        const threadId = await this.resolveThread(job);
-        const sendResult = await workspaceRouter.sendThreadMessage(threadId, job.promptTemplate, {
-            permissionMode: SCHEDULED_RUN_PERMISSION_MODE,
-        });
-        await this.waitForRun(sendResult.runId);
-        const thread = await workspaceRouter.getThread(threadId);
-        const replyText = [...thread.messages]
-            .reverse()
-            .find((message) => message.role === 'assistant' && message.kind === 'final')
-            ?.content;
+        const execution = await this.executor.execute(job, job.promptTemplate, this.createExecutionPolicy());
+        return {
+            threadId: execution.threadId,
+            runId: execution.runId,
+            replyText: execution.replyText,
+            deliveryMode: 'thread-only',
+            deliveryStatus: 'succeeded',
+        };
+    }
+    createExecutionPolicy() {
         return {
-            threadId,
-            runId: sendResult.runId,
-            replyText,
+            resolveTarget: async (job) => ({
+                kind: 'local:thread',
+                threadId: await this.resolveThread(job),
+                workspaceId: job.workspaceId,
+                platform: job.platform,
+                route: job.route,
+            }),
         };
     }
     async resolveThread(job) {
@@ -54,19 +61,5 @@ class LocalScheduleAdapter {
             return false;
         }
     }
-    async waitForRun(runId, timeoutMs = 15 * 60 * 1000) {
-        const startedAt = Date.now();
-        while (Date.now() - startedAt < timeoutMs) {
-            const run = this.options.store.getRun(runId);
-            if (run && TERMINAL_RUN_STATES.has(run.status)) {
-                if (run.status !== 'completed') {
-                    throw new Error(`Scheduled run finished with status ${run.status}`);
-                }
-                return;
-            }
-            await new Promise((resolve) => setTimeout(resolve, 300));
-        }
-        throw new Error(`Timed out waiting for scheduled run ${runId}`);
-    }
 }
 exports.LocalScheduleAdapter = LocalScheduleAdapter;

package/dist-electron/services/local-ai-core/src/scheduler/scheduled-bridge-session.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduledBridgeSession = void 0;
+class ScheduledBridgeSession {
+    static async open(input) {
+        const sessionKey = input.workspaceRouter.getThreadSessionKey(input.threadId);
+        const channelRuntime = input.getChannelRuntime();
+        const unregister = await channelRuntime.registerScheduledThreadBridge?.({
+            workspaceId: input.job.workspaceId,
+            platform: input.job.platform,
+            route: input.job.route,
+            threadId: input.threadId,
+            sessionKey,
+        });
+        await sendScheduledStartNotice(channelRuntime, input.job, sessionKey);
+        return {
+            mode: 'bridge-stream',
+            workspaceId: input.job.workspaceId,
+            platform: input.job.platform,
+            route: input.job.route,
+            threadId: input.threadId,
+            sessionKey,
+            close: async () => {
+                await unregister?.();
+            },
+        };
+    }
+}
+exports.ScheduledBridgeSession = ScheduledBridgeSession;
+async function sendScheduledStartNotice(channelRuntime, job, sessionKey) {
+    if (!channelRuntime.onBridgeEvent) {
+        return;
+    }
+    try {
+        await channelRuntime.onBridgeEvent({
+            type: 'status',
+            sessionKey,
+            bridgeKind: 'status',
+            content: `⏰ ${scheduledNoticeTitle(job)}`,
+        });
+    }
+    catch {
+        // The scheduled run should continue even if the proactive start notice fails.
+    }
+}
+function scheduledNoticeTitle(job) {
+    const title = normalizeNoticeTitle(job.description) || normalizeNoticeTitle(job.promptTemplate) || job.id;
+    return truncateNoticeTitle(title, 80);
+}
+function normalizeNoticeTitle(value) {
+    return String(value || '').replace(/\s+/g, ' ').trim();
+}
+function truncateNoticeTitle(value, maxLength) {
+    return value.length > maxLength ? `${value.slice(0, maxLength - 1)}…` : value;
+}

package/dist-electron/services/local-ai-core/src/scheduler/scheduler-run-lifecycle.js

@@ -10,13 +10,18 @@ class SchedulerRunLifecycle {
         const skipped = this.options.store.createScheduledJobRun(job.id, 'skipped', {
             triggeredAt,
             error,
+            deliveryStatus: 'skipped',
+            deliveryError: error,
         });
         this.options.emitRun(skipped);
         this.emitCurrentJob(job.id);
         return skipped;
     }
     markQueued(job, triggeredAt) {
-        const run = this.options.store.createScheduledJobRun(job.id, 'queued', { triggeredAt });
+        const run = this.options.store.createScheduledJobRun(job.id, 'queued', {
+            triggeredAt,
+            deliveryStatus: 'pending',
+        });
         this.options.emitRun(run);
         return run;
     }
@@ -35,6 +40,11 @@ class SchedulerRunLifecycle {
             threadId: result.threadId,
             runId: result.runId,
             platformMessageId: result.platformMessageId,
+            platformMessageIds: result.platformMessageIds,
+            deliveryMode: result.deliveryMode,
+            deliveryStatus: result.deliveryStatus || 'succeeded',
+            deliveryError: result.deliveryError || '',
+            lastBridgeEventAt: result.lastBridgeEventAt,
             error: '',
         });
         if (disableOnceJob) {
@@ -49,6 +59,8 @@ class SchedulerRunLifecycle {
             status: 'failed',
             finishedAt: new Date().toISOString(),
             error,
+            deliveryStatus: 'failed',
+            deliveryError: error,
         });
         this.options.emitRun(failed);
         this.emitCurrentJob(jobId);

package/dist-electron/services/local-ai-core/src/scheduler/scheduler-service.js

@@ -98,7 +98,7 @@ class SchedulerService extends node_events_1.EventEmitter {
                 if (!this.isDue(job, now)) {
                     continue;
                 }
-                await this.executeJob(job, now.toISOString(), false);
+                void this.executeJob(job, now.toISOString(), false);
             }
         }
         finally {

package/dist-electron/services/local-ai-core/src/scheduler/weixin-execution-policies.js

@@ -1,66 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createWeixinExecutionPolicy = createWeixinExecutionPolicy;
+const channel_execution_policy_js_1 = require("./channel-execution-policy.js");
 function createWeixinExecutionPolicy(job, options, resolveSameThread) {
-    if (job.executionMode === 'side-thread') {
-        return new WeixinSideThreadExecutionPolicy(options);
-    }
-    return new WeixinSameThreadExecutionPolicy(options, resolveSameThread);
-}
-class WeixinSameThreadExecutionPolicy {
-    options;
-    resolveSameThread;
-    constructor(options, resolveSameThread) {
-        this.options = options;
-        this.resolveSameThread = resolveSameThread;
-    }
-    async resolveTarget(job) {
-        return {
-            kind: 'thread',
-            threadId: await this.resolveSameThread(job),
-            workspaceId: job.workspaceId,
-            platform: job.platform,
-            route: job.route,
-        };
-    }
-    beforeExecute(target) {
-        this.options.getChannelRuntime().muteThreadBridge?.(target.threadId);
-    }
-    afterExecute(target) {
-        this.options.getChannelRuntime().unmuteThreadBridge?.(target.threadId);
-    }
-}
-class WeixinSideThreadExecutionPolicy {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    async resolveTarget(job) {
-        const title = `[Scheduled] ${job.description || job.id}`;
-        const existing = (await this.options.workspaceRouter.listThreads(job.workspaceId))
-            .find((thread) => thread.title === title);
-        if (existing) {
-            return {
-                kind: 'thread',
-                threadId: existing.id,
-                workspaceId: job.workspaceId,
-                platform: job.platform,
-                route: job.route,
-            };
-        }
-        const created = await this.options.workspaceRouter.createThread(job.workspaceId, title);
-        return {
-            kind: 'thread',
-            threadId: created.id,
-            workspaceId: job.workspaceId,
-            platform: job.platform,
-            route: job.route,
-        };
-    }
-    beforeExecute(target) {
-        this.options.getChannelRuntime().muteThreadBridge?.(target.threadId);
-    }
-    afterExecute(target) {
-        this.options.getChannelRuntime().unmuteThreadBridge?.(target.threadId);
-    }
+    return (0, channel_execution_policy_js_1.createChannelExecutionPolicy)(job, options, {
+        platformBase: 'weixin',
+        resolveSameThread,
+        sideThreadTitle: (nextJob) => `[Scheduled:Weixin] ${nextJob.description || nextJob.id}`,
+        legacySideThreadTitles: (nextJob) => [`[Scheduled] ${nextJob.description || nextJob.id}`],
+    });
 }

package/dist-electron/services/local-ai-core/src/scheduler/weixin-schedule-adapter.js

@@ -26,22 +26,13 @@ class WeixinScheduleAdapter {
             getChannelRuntime: this.options.getChannelRuntime,
         }, (nextJob) => this.resolveThread(nextJob));
         const execution = await this.executor.execute(job, job.promptTemplate, executionPolicy);
-        let platformMessageId = '';
-        if (execution.replyText) {
-            const channelRuntime = this.options.getChannelRuntime();
-            if (!channelRuntime.sendScheduledMessage) {
-                throw new Error('WeChat channel runtime does not support scheduled delivery.');
-            }
-            platformMessageId = await channelRuntime.sendScheduledMessage(job.workspaceId, (0, scheduled_job_route_js_1.routeWithPlatformInstance)((0, scheduled_job_route_js_1.withoutThreadRoute)(job.route), job.platform), execution.replyText);
-            if (!platformMessageId) {
-                throw new Error('WeChat gateway did not return a message id for scheduled delivery.');
-            }
-        }
         return {
             threadId: execution.threadId,
             runId: execution.runId,
             replyText: execution.replyText,
-            platformMessageId: platformMessageId || undefined,
+            deliveryMode: 'bridge-stream',
+            deliveryStatus: 'succeeded',
+            lastBridgeEventAt: new Date().toISOString(),
         };
     }
     async resolveThread(job) {