@kafca/agentdock 0.1.7

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLarkExecutionPolicy = createLarkExecutionPolicy;
+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);
+    }
+}

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LarkScheduleAdapter = void 0;
+const scheduled_conversation_executor_js_1 = require("./scheduled-conversation-executor.js");
+const lark_execution_policies_js_1 = require("./lark-execution-policies.js");
+class LarkScheduleAdapter {
+    options;
+    executor;
+    deliveryTargets = ['lark'];
+    constructor(options) {
+        this.options = options;
+        this.executor = new scheduled_conversation_executor_js_1.ScheduledConversationExecutor({
+            store: options.store,
+            workspaceRouter: options.getWorkspaceRouter(),
+        });
+    }
+    supports(job) {
+        return job.platform === 'lark' && (job.route.type === 'channel.chat' || job.route.type === 'lark_chat');
+    }
+    async execute(context) {
+        const { job } = context;
+        const executionPolicy = (0, lark_execution_policies_js_1.createLarkExecutionPolicy)(job, {
+            store: this.options.store,
+            workspaceRouter: this.options.getWorkspaceRouter(),
+            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, job.route, 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,
+        };
+    }
+    async resolveThread(job) {
+        const workspaceRouter = this.options.getWorkspaceRouter();
+        const route = job.route;
+        if (route.threadId) {
+            await workspaceRouter.getThread(route.threadId);
+            return route.threadId;
+        }
+        const channelId = route.channelId;
+        const participantId = route.participantId || '';
+        const binding = this.options.store.getPlatformThreadBinding(job.workspaceId, channelId, participantId);
+        if (binding?.thread_id) {
+            return binding.thread_id;
+        }
+        const thread = await workspaceRouter.createThread(job.workspaceId, job.description || `Scheduled ${job.platform} task`);
+        const now = new Date().toISOString();
+        this.options.store.upsertPlatformThreadBinding({
+            workspace_id: job.workspaceId,
+            chat_id: channelId,
+            platform_user_id: participantId,
+            thread_id: thread.id,
+            last_platform_message_id: null,
+            created_at: now,
+            updated_at: now,
+        });
+        const authorized = this.options.store.getAuthorizedUser(job.workspaceId, participantId);
+        if (authorized) {
+            this.options.store.updateAuthorizedUserThread(job.workspaceId, participantId, thread.id);
+        }
+        return thread.id;
+    }
+}
+exports.LarkScheduleAdapter = LarkScheduleAdapter;

package/dist-electron/services/local-ai-core/src/scheduler/scheduled-conversation-executor.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduledConversationExecutor = void 0;
+const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'interrupted']);
+class ScheduledConversationExecutor {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async execute(job, prompt, policy, timeoutMs = 15 * 60 * 1000) {
+        const target = await policy.resolveTarget(job);
+        await policy.beforeExecute?.(target, job);
+        try {
+            const sendResult = await this.options.workspaceRouter.sendThreadMessage(target.threadId, prompt);
+            await this.waitForRun(sendResult.runId, timeoutMs);
+            const thread = await this.options.workspaceRouter.getThread(target.threadId);
+            const replyText = [...thread.messages]
+                .reverse()
+                .find((message) => message.role === 'assistant' && message.kind === 'final')
+                ?.content;
+            return {
+                threadId: target.threadId,
+                runId: sendResult.runId,
+                replyText,
+            };
+        }
+        finally {
+            await policy.afterExecute?.(target, job);
+        }
+    }
+    async waitForRun(runId, timeoutMs) {
+        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 run;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 300));
+        }
+        throw new Error(`Timed out waiting for scheduled run ${runId}`);
+    }
+}
+exports.ScheduledConversationExecutor = ScheduledConversationExecutor;

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchedulerRunLifecycle = void 0;
+class SchedulerRunLifecycle {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    markSkipped(job, triggeredAt, error) {
+        const skipped = this.options.store.createScheduledJobRun(job.id, 'skipped', {
+            triggeredAt,
+            error,
+        });
+        this.options.emitRun(skipped);
+        this.emitCurrentJob(job.id);
+        return skipped;
+    }
+    markQueued(job, triggeredAt) {
+        const run = this.options.store.createScheduledJobRun(job.id, 'queued', { triggeredAt });
+        this.options.emitRun(run);
+        return run;
+    }
+    markRunning(runId) {
+        const started = this.options.store.updateScheduledJobRun(runId, {
+            status: 'running',
+            startedAt: new Date().toISOString(),
+        });
+        this.options.emitRun(started);
+        return started;
+    }
+    markSucceeded(job, runId, result, disableOnceJob) {
+        const completed = this.options.store.updateScheduledJobRun(runId, {
+            status: 'succeeded',
+            finishedAt: new Date().toISOString(),
+            threadId: result.threadId,
+            runId: result.runId,
+            platformMessageId: result.platformMessageId,
+            error: '',
+        });
+        if (disableOnceJob) {
+            this.options.store.updateScheduledJobStatus(job.id, { enabled: false });
+        }
+        this.options.emitRun(completed);
+        this.emitCurrentJob(job.id);
+        return completed;
+    }
+    markFailed(jobId, runId, error) {
+        const failed = this.options.store.updateScheduledJobRun(runId, {
+            status: 'failed',
+            finishedAt: new Date().toISOString(),
+            error,
+        });
+        this.options.emitRun(failed);
+        this.emitCurrentJob(jobId);
+        return failed;
+    }
+    emitCurrentJob(jobId) {
+        const job = this.options.store.getScheduledJob(jobId);
+        if (job) {
+            this.options.emitJob(job);
+        }
+    }
+}
+exports.SchedulerRunLifecycle = SchedulerRunLifecycle;

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

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchedulerService = void 0;
+const node_events_1 = require("node:events");
+const scheduler_run_lifecycle_js_1 = require("./scheduler-run-lifecycle.js");
+class SchedulerService extends node_events_1.EventEmitter {
+    options;
+    timer = null;
+    pollInFlight = false;
+    runningJobs = new Set();
+    runLifecycle;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.runLifecycle = new scheduler_run_lifecycle_js_1.SchedulerRunLifecycle({
+            store: options.store,
+            emitRun: (run) => this.emit('run', run),
+            emitJob: (job) => this.emit('job', job),
+        });
+    }
+    async start() {
+        await this.tick();
+        this.timer = setInterval(() => {
+            void this.tick();
+        }, 1000);
+    }
+    async stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    listJobs(workspaceId) {
+        return this.options.store.listScheduledJobs(workspaceId);
+    }
+    getJob(jobId) {
+        return this.options.store.getScheduledJob(jobId);
+    }
+    createJob(input) {
+        const job = this.options.store.createScheduledJob(input);
+        this.emit('job', job);
+        this.options.eventBus.emit({ type: 'scheduler.job.updated', payload: job });
+        return job;
+    }
+    updateJob(jobId, input) {
+        const job = this.options.store.updateScheduledJob(jobId, input);
+        this.emit('job', job);
+        this.options.eventBus.emit({ type: 'scheduler.job.updated', payload: job });
+        return job;
+    }
+    deleteJob(jobId) {
+        return this.options.store.deleteScheduledJob(jobId);
+    }
+    listJobRuns(jobId) {
+        return this.options.store.listScheduledJobRuns(jobId);
+    }
+    async runJobNow(jobId) {
+        const job = this.options.store.getScheduledJob(jobId);
+        if (!job) {
+            throw new Error(`Scheduled job not found: ${jobId}`);
+        }
+        return this.executeJob(job, new Date().toISOString(), true);
+    }
+    async tick() {
+        if (this.pollInFlight) {
+            return;
+        }
+        this.pollInFlight = true;
+        try {
+            const now = new Date();
+            const jobs = this.options.store.listScheduledJobs().filter((job) => job.enabled);
+            for (const job of jobs) {
+                if (!this.isDue(job, now)) {
+                    continue;
+                }
+                await this.executeJob(job, now.toISOString(), false);
+            }
+        }
+        finally {
+            this.pollInFlight = false;
+        }
+    }
+    isDue(job, now) {
+        const trigger = this.options.triggers.find((candidate) => candidate.supports(job));
+        if (!trigger) {
+            return false;
+        }
+        return trigger.isDue(job, now);
+    }
+    async executeJob(job, triggeredAt, manual) {
+        if (this.runningJobs.has(job.id)) {
+            const skipped = this.runLifecycle.markSkipped(job, triggeredAt, 'Skipped because the previous run is still active.');
+            this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: skipped });
+            return skipped;
+        }
+        this.runningJobs.add(job.id);
+        const run = this.runLifecycle.markQueued(job, triggeredAt);
+        this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: run });
+        try {
+            const executor = this.options.executors.find((candidate) => candidate.supports(job));
+            if (!executor) {
+                throw new Error(`No scheduler executor is available for delivery target "${job.platform}"`);
+            }
+            this.runLifecycle.markRunning(run.id);
+            const running = this.options.store.getScheduledJobRun(run.id);
+            if (running) {
+                this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: running });
+            }
+            const result = await executor.execute({ job, triggeredAt });
+            const succeeded = this.runLifecycle.markSucceeded(job, run.id, result, !manual && job.triggerType === 'once');
+            this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: succeeded });
+            const nextJob = this.options.store.getScheduledJob(job.id);
+            if (nextJob) {
+                this.options.eventBus.emit({ type: 'scheduler.job.updated', payload: nextJob });
+            }
+            return succeeded;
+        }
+        catch (error) {
+            const failed = this.runLifecycle.markFailed(job.id, run.id, error instanceof Error ? error.message : String(error));
+            this.options.eventBus.emit({ type: 'scheduler.run.updated', payload: failed });
+            const nextJob = this.options.store.getScheduledJob(job.id);
+            if (nextJob) {
+                this.options.eventBus.emit({ type: 'scheduler.job.updated', payload: nextJob });
+            }
+            this.options.log?.(`scheduler job failed ${job.id}: ${failed.error || 'unknown error'}`);
+            return failed;
+        }
+        finally {
+            this.runningJobs.delete(job.id);
+        }
+    }
+}
+exports.SchedulerService = SchedulerService;

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWeixinExecutionPolicy = createWeixinExecutionPolicy;
+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);
+    }
+}

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeixinScheduleAdapter = void 0;
+const scheduled_conversation_executor_js_1 = require("./scheduled-conversation-executor.js");
+const weixin_execution_policies_js_1 = require("./weixin-execution-policies.js");
+class WeixinScheduleAdapter {
+    options;
+    executor;
+    deliveryTargets = ['weixin'];
+    constructor(options) {
+        this.options = options;
+        this.executor = new scheduled_conversation_executor_js_1.ScheduledConversationExecutor({
+            store: options.store,
+            workspaceRouter: options.getWorkspaceRouter(),
+        });
+    }
+    supports(job) {
+        return job.platform === 'weixin' && (job.route.type === 'channel.chat' || job.route.type === 'weixin_chat');
+    }
+    async execute(context) {
+        const { job } = context;
+        const executionPolicy = (0, weixin_execution_policies_js_1.createWeixinExecutionPolicy)(job, {
+            store: this.options.store,
+            workspaceRouter: this.options.getWorkspaceRouter(),
+            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, job.route, 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,
+        };
+    }
+    async resolveThread(job) {
+        const workspaceRouter = this.options.getWorkspaceRouter();
+        const route = job.route;
+        if (route.threadId) {
+            await workspaceRouter.getThread(route.threadId);
+            return route.threadId;
+        }
+        const channelId = route.channelId;
+        const participantId = route.participantId || '';
+        const binding = this.options.store.getPlatformThreadBinding(job.workspaceId, channelId, participantId, 'weixin');
+        if (binding?.thread_id) {
+            return binding.thread_id;
+        }
+        const thread = await workspaceRouter.createThread(job.workspaceId, job.description || `Scheduled ${job.platform} task`);
+        const now = new Date().toISOString();
+        this.options.store.upsertPlatformThreadBinding({
+            workspace_id: job.workspaceId,
+            platform: 'weixin',
+            chat_id: channelId,
+            platform_user_id: participantId,
+            thread_id: thread.id,
+            last_platform_message_id: null,
+            created_at: now,
+            updated_at: now,
+        });
+        const authorized = this.options.store.getAuthorizedUser(job.workspaceId, participantId, 'weixin');
+        if (authorized) {
+            this.options.store.updateAuthorizedUserThread(job.workspaceId, participantId, thread.id, 'weixin');
+        }
+        return thread.id;
+    }
+}
+exports.WeixinScheduleAdapter = WeixinScheduleAdapter;

package/dist-electron/services/local-ai-core/src/thread/workspace-thread-id.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeThreadId = encodeThreadId;
+exports.decodeThreadId = decodeThreadId;
+function encodeThreadId(workspaceId, sessionId) {
+    return `${encodeURIComponent(workspaceId)}::${encodeURIComponent(sessionId)}`;
+}
+function decodeThreadId(threadId) {
+    const [workspacePart, sessionPart] = threadId.split('::');
+    if (!workspacePart || !sessionPart) {
+        throw new Error(`Invalid thread id: ${threadId}`);
+    }
+    return {
+        workspaceId: decodeURIComponent(workspacePart),
+        sessionId: decodeURIComponent(sessionPart),
+    };
+}

package/dist-electron/services/local-ai-core/src/thread/workspace-thread-mappers.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeMessageContent = normalizeMessageContent;
+exports.toThreadMessages = toThreadMessages;
+exports.toThreadSummary = toThreadSummary;
+exports.toThreadDetail = toThreadDetail;
+const workspace_thread_id_js_1 = require("./workspace-thread-id.js");
+function normalizeMessageContent(content) {
+    return String(content || '').replace(/\n/g, ' ').trim();
+}
+function toThreadMessages(history) {
+    return history.map((message, index) => ({
+        id: `${message.timestamp || index}-${message.role}-${index}`,
+        role: message.role === 'user' ? 'user' : message.role === 'assistant' ? 'assistant' : 'system',
+        content: message.content,
+        timestamp: message.timestamp,
+        kind: message.kind === 'progress' ? 'progress' : message.role === 'system' ? 'system' : 'final',
+    }));
+}
+function toThreadSummary(workspaceId, session) {
+    const id = (0, workspace_thread_id_js_1.encodeThreadId)(workspaceId, session.id);
+    return {
+        id,
+        workspaceId,
+        title: String(session.name || session.user_name || session.chat_name || session.id).trim(),
+        live: Boolean(session.live || session.active),
+        updatedAt: session.updated_at,
+        createdAt: session.created_at,
+        historyCount: session.history_count,
+        excerpt: normalizeMessageContent(session.last_message?.content),
+        participantName: session.user_name || session.chat_name,
+        runId: session.live ? `run:${id}` : undefined,
+        bridgeSessionKey: session.session_key,
+        agentType: session.agent_type,
+    };
+}
+function toThreadDetail(workspaceId, session, selectedKnowledgeBaseIds = []) {
+    return {
+        ...toThreadSummary(workspaceId, session),
+        messages: toThreadMessages(session.history || []),
+        selectedKnowledgeBaseIds,
+    };
+}