@kafca/agentdock 0.1.41 → 0.1.43

package/dist-electron/services/local-ai-core/src/acp/store/local-core-acp-store.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactSecrets = exports.LocalCoreAcpStore = void 0;
+const node_fs_1 = require("node:fs");
+const node_sqlite_1 = require("node:sqlite");
+const node_path_1 = require("node:path");
+const desktop_js_1 = require("../../../../../shared/desktop.js");
+const agent_task_store_js_1 = require("./agent-task-store.js");
+const automation_monitor_store_js_1 = require("./automation-monitor-store.js");
+const schema_js_1 = require("./schema.js");
+const platform_store_js_1 = require("./platform-store.js");
+const scheduler_store_js_1 = require("./scheduler-store.js");
+const security_store_js_1 = require("./security-store.js");
+const thread_store_js_1 = require("./thread-store.js");
+const workspace_registry_store_js_1 = require("./workspace-registry-store.js");
+class LocalCoreAcpStore {
+    db;
+    threads;
+    workspaceRegistry;
+    security;
+    agentTasks;
+    scheduler;
+    automationMonitors;
+    platform;
+    constructor(userDataPath) {
+        const dbPath = (0, node_path_1.join)(userDataPath, 'runtime', 'local-core.db');
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(dbPath), { recursive: true });
+        this.db = new node_sqlite_1.DatabaseSync(dbPath);
+        this.threads = new thread_store_js_1.LocalThreadStore(this.db);
+        this.workspaceRegistry = new workspace_registry_store_js_1.LocalWorkspaceRegistryStore(this.db);
+        this.security = new security_store_js_1.LocalSecurityStore(this.db, (taskId, input) => {
+            this.agentTasks.update(taskId, input);
+        });
+        this.agentTasks = new agent_task_store_js_1.LocalAgentTaskStore(this.db, (input) => {
+            this.security.createAuditEvent(input);
+        });
+        this.scheduler = new scheduler_store_js_1.LocalSchedulerStore(this.db);
+        this.automationMonitors = new automation_monitor_store_js_1.LocalAutomationMonitorStore(this.db);
+        this.platform = new platform_store_js_1.LocalPlatformStore(this.db);
+        (0, schema_js_1.ensureLocalCoreAcpSchema)(this.db);
+    }
+    close() {
+        this.db.close();
+    }
+    listThreadSummaries(workspaceId) {
+        return this.threads.listSummaries(workspaceId);
+    }
+    countThreads(workspaceId) {
+        return this.threads.count(workspaceId);
+    }
+    createThread(workspaceId, title, agentType = desktop_js_1.LOCALCORE_ACP_AGENT_TYPE, agentMode = 'default') {
+        return this.threads.create(workspaceId, title, agentType, agentMode);
+    }
+    getThread(threadId, selectedKnowledgeBaseIds) {
+        return this.threads.get(threadId, selectedKnowledgeBaseIds);
+    }
+    renameThread(threadId, title) {
+        this.threads.rename(threadId, title);
+    }
+    deleteThread(threadId) {
+        this.platform.clearAuthorizedUserThreadByThreadId(threadId);
+        this.platform.deletePlatformThreadBindingsByThreadId(threadId);
+        this.threads.delete(threadId);
+    }
+    appendMessage(threadId, role, content, kind, toolCall, bridgeKind, bridgeStatus) {
+        return this.threads.appendMessage(threadId, role, content, kind, toolCall, bridgeKind, bridgeStatus);
+    }
+    upsertMessage(threadId, id, role, content, kind, toolCall, bridgeKind, bridgeStatus) {
+        return this.threads.upsertMessage(threadId, id, role, content, kind, toolCall, bridgeKind, bridgeStatus);
+    }
+    updateRun(runId, threadId, status) {
+        this.threads.updateRun(runId, threadId, status);
+    }
+    getLatestRunForThread(threadId) {
+        return this.threads.getLatestRunForThread(threadId);
+    }
+    getRun(runId) {
+        return this.threads.getRun(runId);
+    }
+    listWorkspaceRegistry() {
+        return this.workspaceRegistry.list();
+    }
+    getWorkspaceRegistryEntry(workspaceId) {
+        return this.workspaceRegistry.get(workspaceId);
+    }
+    upsertWorkspaceRegistryEntry(input) {
+        return this.workspaceRegistry.upsert(input);
+    }
+    updateWorkspaceRegistryEntry(workspaceId, input) {
+        return this.workspaceRegistry.update(workspaceId, input);
+    }
+    deleteWorkspaceRegistryEntry(workspaceId) {
+        return this.workspaceRegistry.delete(workspaceId);
+    }
+    touchWorkspaceRegistryEntry(workspaceId) {
+        this.workspaceRegistry.touch(workspaceId);
+    }
+    getWorkspaceSecuritySettings(workspaceId) {
+        return this.security.getWorkspaceSecuritySettings(workspaceId);
+    }
+    updateWorkspaceSecuritySettings(workspaceId, input) {
+        return this.security.updateWorkspaceSecuritySettings(workspaceId, input);
+    }
+    createApprovalRequest(input) {
+        return this.security.createApprovalRequest(input);
+    }
+    listApprovalRequests(query = {}) {
+        return this.security.listApprovalRequests(query);
+    }
+    getApprovalRequest(approvalId) {
+        return this.security.getApprovalRequest(approvalId);
+    }
+    resolveApprovalRequest(approvalId, input) {
+        return this.security.resolveApprovalRequest(approvalId, input);
+    }
+    createAuditEvent(input) {
+        return this.security.createAuditEvent(input);
+    }
+    listAuditEvents(query = {}) {
+        return this.security.listAuditEvents(query);
+    }
+    createAgentTask(input) {
+        return this.agentTasks.create(input);
+    }
+    listAgentTasks(query = {}) {
+        return this.agentTasks.list(query);
+    }
+    getAgentTask(taskId) {
+        return this.agentTasks.get(taskId);
+    }
+    getAgentTaskByRunId(runId) {
+        return this.agentTasks.getByRunId(runId);
+    }
+    updateAgentTask(taskId, input) {
+        return this.agentTasks.update(taskId, input);
+    }
+    listScheduledJobs(workspaceId) {
+        return this.scheduler.listJobs(workspaceId);
+    }
+    getScheduledJob(jobId) {
+        return this.scheduler.getJob(jobId);
+    }
+    createScheduledJob(input) {
+        return this.scheduler.createJob(input);
+    }
+    updateScheduledJob(jobId, input) {
+        return this.scheduler.updateJob(jobId, input);
+    }
+    deleteScheduledJob(jobId) {
+        return this.scheduler.deleteJob(jobId);
+    }
+    listScheduledJobRuns(jobId) {
+        return this.scheduler.listRuns(jobId);
+    }
+    createScheduledJobRun(jobId, status, input = {}) {
+        return this.scheduler.createRun(jobId, status, input);
+    }
+    getScheduledJobRun(runId) {
+        return this.scheduler.getRun(runId);
+    }
+    updateScheduledJobRun(runId, input) {
+        return this.scheduler.updateRun(runId, input);
+    }
+    updateScheduledJobStatus(jobId, input) {
+        this.scheduler.updateJobStatus(jobId, input);
+    }
+    listAutomationMonitors(workspaceId) {
+        return this.automationMonitors.list(workspaceId);
+    }
+    getAutomationMonitor(monitorId) {
+        return this.automationMonitors.get(monitorId);
+    }
+    createAutomationMonitor(input) {
+        return this.automationMonitors.create(input);
+    }
+    updateAutomationMonitor(monitorId, input) {
+        return this.automationMonitors.update(monitorId, input);
+    }
+    updateAutomationMonitorState(monitorId, input) {
+        this.automationMonitors.updateState(monitorId, input);
+    }
+    deleteAutomationMonitor(monitorId) {
+        return this.automationMonitors.delete(monitorId);
+    }
+    listAutomationMonitorRuns(monitorId) {
+        return this.automationMonitors.listRuns(monitorId);
+    }
+    createAutomationMonitorRun(monitorId, status, input = {}) {
+        return this.automationMonitors.createRun(monitorId, status, input);
+    }
+    getAutomationMonitorRun(runId) {
+        return this.automationMonitors.getRun(runId);
+    }
+    updateAutomationMonitorRun(runId, input) {
+        return this.automationMonitors.updateRun(runId, input);
+    }
+    getThreadRow(threadId) {
+        return this.threads.getRow(threadId);
+    }
+    updateThreadAgentMode(threadId, mode) {
+        this.threads.updateAgentMode(threadId, mode);
+    }
+    updateThreadAgentType(threadId, agentType) {
+        this.threads.updateAgentType(threadId, agentType);
+    }
+    updateThreadSession(threadId, sessionId, supportsLoad) {
+        this.threads.updateSession(threadId, sessionId, supportsLoad);
+    }
+    createPairingRequest(input) {
+        this.platform.createPairingRequest(input);
+    }
+    listPendingPairings(workspaceId) {
+        return this.platform.listPendingPairings(workspaceId);
+    }
+    getPairingRequest(code) {
+        return this.platform.getPairingRequest(code);
+    }
+    updatePairingStatus(code, status) {
+        this.platform.updatePairingStatus(code, status);
+    }
+    expirePendingPairings(nowIso = new Date().toISOString()) {
+        this.platform.expirePendingPairings(nowIso);
+    }
+    getAuthorizedUser(workspaceId, platformUserId, platform = 'lark') {
+        return this.platform.getAuthorizedUser(workspaceId, platformUserId, platform);
+    }
+    listAuthorizedUsers(workspaceId, platform) {
+        return this.platform.listAuthorizedUsers(workspaceId, platform);
+    }
+    createAuthorizedUser(input) {
+        this.platform.createAuthorizedUser(input);
+    }
+    updateAuthorizedUserThread(workspaceId, platformUserId, threadId, platform = 'lark') {
+        this.platform.updateAuthorizedUserThread(workspaceId, platformUserId, threadId, platform);
+    }
+    clearAuthorizedUserThreadByThreadId(threadId) {
+        this.platform.clearAuthorizedUserThreadByThreadId(threadId);
+    }
+    getPlatformThreadBinding(workspaceId, chatId, platformUserId, platform = 'lark') {
+        return this.platform.getPlatformThreadBinding(workspaceId, chatId, platformUserId, platform);
+    }
+    getPlatformThreadBindingByThreadId(threadId) {
+        return this.platform.getPlatformThreadBindingByThreadId(threadId);
+    }
+    deletePlatformThreadBindingsByThreadId(threadId) {
+        this.platform.deletePlatformThreadBindingsByThreadId(threadId);
+    }
+    upsertPlatformThreadBinding(input) {
+        this.platform.upsertPlatformThreadBinding(input);
+    }
+    updatePlatformThreadMessageId(workspaceId, chatId, platformUserId, messageId, platform = 'lark') {
+        this.platform.updatePlatformThreadMessageId(workspaceId, chatId, platformUserId, messageId, platform);
+    }
+    clearPlatformThreadMessageId(workspaceId, chatId, platformUserId, platform = 'lark') {
+        this.platform.clearPlatformThreadMessageId(workspaceId, chatId, platformUserId, platform);
+    }
+    listPairingRequests(workspaceId, platform) {
+        return this.platform.listPairingRequests(workspaceId, platform);
+    }
+}
+exports.LocalCoreAcpStore = LocalCoreAcpStore;
+var utils_js_1 = require("./utils.js");
+Object.defineProperty(exports, "redactSecrets", { enumerable: true, get: function () { return utils_js_1.redactSecrets; } });

package/dist-electron/services/local-ai-core/src/acp/store/platform-store.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalPlatformStore = void 0;
+class LocalPlatformStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    createPairingRequest(input) {
+        this.db.prepare(`
+      INSERT INTO platform_pairings (code, workspace_id, platform, platform_user_id, chat_id, display_name, requested_at, expires_at, status)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(input.code, input.workspace_id, input.platform || 'lark', input.platform_user_id, input.chat_id, input.display_name, input.requested_at, input.expires_at, input.status);
+    }
+    listPendingPairings(workspaceId) {
+        const query = workspaceId
+            ? `
+        SELECT code, workspace_id, platform, platform_user_id, chat_id, display_name, requested_at, expires_at, status
+        FROM platform_pairings
+        WHERE workspace_id = ? AND status = 'pending'
+        ORDER BY requested_at DESC
+      `
+            : `
+        SELECT code, workspace_id, platform, platform_user_id, chat_id, display_name, requested_at, expires_at, status
+        FROM platform_pairings
+        WHERE status = 'pending'
+        ORDER BY requested_at DESC
+      `;
+        return this.db.prepare(query).all(...(workspaceId ? [workspaceId] : []));
+    }
+    getPairingRequest(code) {
+        return this.db.prepare(`
+      SELECT code, workspace_id, platform, platform_user_id, chat_id, display_name, requested_at, expires_at, status
+      FROM platform_pairings
+      WHERE code = ?
+    `).get(code);
+    }
+    updatePairingStatus(code, status) {
+        this.db.prepare('UPDATE platform_pairings SET status = ? WHERE code = ?').run(status, code);
+    }
+    expirePendingPairings(nowIso = new Date().toISOString()) {
+        this.db.prepare(`
+      UPDATE platform_pairings
+      SET status = 'expired'
+      WHERE status = 'pending' AND expires_at < ?
+    `).run(nowIso);
+    }
+    getAuthorizedUser(workspaceId, platformUserId, platform = 'lark') {
+        return this.db.prepare(`
+      SELECT id, workspace_id, platform, platform_user_id, chat_id, display_name, thread_id, authorized_at
+      FROM platform_users
+      WHERE workspace_id = ? AND platform = ? AND platform_user_id = ?
+    `).get(workspaceId, platform, platformUserId);
+    }
+    listAuthorizedUsers(workspaceId, platform) {
+        const params = [];
+        const predicates = [];
+        if (workspaceId) {
+            predicates.push('workspace_id = ?');
+            params.push(workspaceId);
+        }
+        if (platform) {
+            predicates.push('platform = ?');
+            params.push(platform);
+        }
+        const where = predicates.length > 0 ? `WHERE ${predicates.join(' AND ')}` : '';
+        const query = `
+        SELECT id, workspace_id, platform, platform_user_id, chat_id, display_name, thread_id, authorized_at
+        FROM platform_users
+        ${where}
+        ORDER BY authorized_at DESC
+      `;
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map((row) => ({
+            id: row.id,
+            workspaceId: row.workspace_id,
+            platform: row.platform,
+            participantId: row.platform_user_id,
+            channelId: row.chat_id,
+            platformUserId: row.platform_user_id,
+            chatId: row.chat_id,
+            displayName: row.display_name,
+            threadId: row.thread_id || undefined,
+            authorizedAt: row.authorized_at,
+        }));
+    }
+    createAuthorizedUser(input) {
+        this.db.prepare(`
+      INSERT INTO platform_users (id, workspace_id, platform, platform_user_id, chat_id, display_name, thread_id, authorized_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(workspace_id, platform, platform_user_id) DO UPDATE SET
+        chat_id = excluded.chat_id,
+        display_name = excluded.display_name,
+        thread_id = COALESCE(excluded.thread_id, platform_users.thread_id),
+        authorized_at = excluded.authorized_at
+    `).run(input.id, input.workspace_id, input.platform || 'lark', input.platform_user_id, input.chat_id, input.display_name, input.thread_id, input.authorized_at);
+    }
+    updateAuthorizedUserThread(workspaceId, platformUserId, threadId, platform = 'lark') {
+        this.db.prepare(`
+      UPDATE platform_users
+      SET thread_id = ?
+      WHERE workspace_id = ? AND platform = ? AND platform_user_id = ?
+    `).run(threadId, workspaceId, platform, platformUserId);
+    }
+    clearAuthorizedUserThreadByThreadId(threadId) {
+        this.db.prepare('UPDATE platform_users SET thread_id = NULL WHERE thread_id = ?').run(threadId);
+    }
+    getPlatformThreadBinding(workspaceId, chatId, platformUserId, platform = 'lark') {
+        return this.db.prepare(`
+      SELECT workspace_id, platform, chat_id, platform_user_id, thread_id, last_platform_message_id, created_at, updated_at
+      FROM platform_thread_bindings
+      WHERE workspace_id = ? AND platform = ? AND chat_id = ? AND platform_user_id = ?
+    `).get(workspaceId, platform, chatId, platformUserId);
+    }
+    getPlatformThreadBindingByThreadId(threadId) {
+        return this.db.prepare(`
+      SELECT workspace_id, platform, chat_id, platform_user_id, thread_id, last_platform_message_id, created_at, updated_at
+      FROM platform_thread_bindings
+      WHERE thread_id = ?
+      ORDER BY updated_at DESC
+      LIMIT 1
+    `).get(threadId);
+    }
+    deletePlatformThreadBindingsByThreadId(threadId) {
+        this.db.prepare('DELETE FROM platform_thread_bindings WHERE thread_id = ?').run(threadId);
+    }
+    upsertPlatformThreadBinding(input) {
+        this.db.prepare(`
+      INSERT INTO platform_thread_bindings
+      (workspace_id, platform, chat_id, platform_user_id, thread_id, last_platform_message_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(workspace_id, platform, chat_id, platform_user_id) DO UPDATE SET
+        thread_id = excluded.thread_id,
+        last_platform_message_id = COALESCE(excluded.last_platform_message_id, platform_thread_bindings.last_platform_message_id),
+        updated_at = excluded.updated_at
+    `).run(input.workspace_id, input.platform || 'lark', input.chat_id, input.platform_user_id, input.thread_id, input.last_platform_message_id, input.created_at, input.updated_at);
+    }
+    updatePlatformThreadMessageId(workspaceId, chatId, platformUserId, messageId, platform = 'lark') {
+        this.db.prepare(`
+      UPDATE platform_thread_bindings
+      SET last_platform_message_id = ?, updated_at = ?
+      WHERE workspace_id = ? AND platform = ? AND chat_id = ? AND platform_user_id = ?
+    `).run(messageId, new Date().toISOString(), workspaceId, platform, chatId, platformUserId);
+    }
+    clearPlatformThreadMessageId(workspaceId, chatId, platformUserId, platform = 'lark') {
+        this.db.prepare(`
+      UPDATE platform_thread_bindings
+      SET last_platform_message_id = NULL, updated_at = ?
+      WHERE workspace_id = ? AND platform = ? AND chat_id = ? AND platform_user_id = ?
+    `).run(new Date().toISOString(), workspaceId, platform, chatId, platformUserId);
+    }
+    listPairingRequests(workspaceId, platform) {
+        const params = [];
+        const predicates = [];
+        if (workspaceId) {
+            predicates.push('workspace_id = ?');
+            params.push(workspaceId);
+        }
+        if (platform) {
+            predicates.push('platform = ?');
+            params.push(platform);
+        }
+        const where = predicates.length > 0 ? `WHERE ${predicates.join(' AND ')}` : '';
+        const query = `
+        SELECT code, workspace_id, platform, platform_user_id, chat_id, display_name, requested_at, expires_at, status
+        FROM platform_pairings
+        ${where}
+        ORDER BY requested_at DESC
+      `;
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map((row) => ({
+            code: row.code,
+            workspaceId: row.workspace_id,
+            platform: row.platform,
+            participantId: row.platform_user_id,
+            channelId: row.chat_id,
+            platformUserId: row.platform_user_id,
+            chatId: row.chat_id,
+            displayName: row.display_name,
+            requestedAt: row.requested_at,
+            expiresAt: row.expires_at,
+            status: row.status,
+        }));
+    }
+}
+exports.LocalPlatformStore = LocalPlatformStore;

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

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalSchedulerStore = void 0;
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("../../../../../packages/contracts/src/index.js");
+const job_id_js_1 = require("../../scheduler/job-id.js");
+const utils_js_1 = require("./utils.js");
+class LocalSchedulerStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    listJobs(workspaceId) {
+        const query = workspaceId
+            ? `
+        SELECT id, workspace_id, platform, route_type, route_config, trigger_type, cron_expr, run_at, prompt_template, description,
+               enabled, concurrency_policy, created_at, updated_at, last_run_at, last_status, last_error, execution_mode
+        FROM scheduled_jobs
+        WHERE workspace_id = ?
+        ORDER BY updated_at DESC
+      `
+            : `
+        SELECT id, workspace_id, platform, route_type, route_config, trigger_type, cron_expr, run_at, prompt_template, description,
+               enabled, concurrency_policy, created_at, updated_at, last_run_at, last_status, last_error, execution_mode
+        FROM scheduled_jobs
+        ORDER BY updated_at DESC
+      `;
+        const rows = this.db.prepare(query).all(...(workspaceId ? [workspaceId] : []));
+        return rows.map((row) => this.toScheduledJob(row));
+    }
+    getJob(jobId) {
+        const row = this.db.prepare(`
+      SELECT id, workspace_id, platform, route_type, route_config, trigger_type, cron_expr, run_at, prompt_template, description,
+             enabled, concurrency_policy, created_at, updated_at, last_run_at, last_status, last_error, execution_mode
+      FROM scheduled_jobs
+      WHERE id = ?
+    `).get(jobId);
+        return row ? this.toScheduledJob(row) : undefined;
+    }
+    createJob(input) {
+        if (!input.platform || !input.route) {
+            throw new Error('Scheduled job creation requires a resolved platform and route.');
+        }
+        let id = (0, job_id_js_1.createScheduledJobId)();
+        for (let attempt = 0; attempt < 5 && this.getJob(id); attempt += 1) {
+            id = (0, job_id_js_1.createScheduledJobId)();
+        }
+        if (this.getJob(id)) {
+            throw new Error('Unable to allocate a unique scheduled job id.');
+        }
+        const now = new Date().toISOString();
+        this.db.prepare(`
+      INSERT INTO scheduled_jobs (
+        id, workspace_id, platform, route_type, route_config, execution_mode, trigger_type, cron_expr, run_at,
+        prompt_template, description, enabled, concurrency_policy, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'skip_if_running', ?, ?)
+    `).run(id, input.workspaceId, (0, index_js_1.normalizeChannelPlatform)(input.platform), input.route.type, JSON.stringify(input.route), (0, index_js_1.normalizeScheduledJobExecutionMode)(input.executionMode), (0, index_js_1.normalizeScheduledJobTriggerType)(input.triggerType), input.cronExpr || null, input.runAt || null, input.promptTemplate, input.description || '', input.enabled === false ? 0 : 1, now, now);
+        return this.getJob(id);
+    }
+    updateJob(jobId, input) {
+        const existing = this.getJob(jobId);
+        if (!existing) {
+            throw new Error(`Scheduled job not found: ${jobId}`);
+        }
+        const next = {
+            ...existing,
+            ...(input.route ? { route: input.route } : {}),
+            ...(input.executionMode ? { executionMode: (0, index_js_1.normalizeScheduledJobExecutionMode)(input.executionMode) } : {}),
+            ...(input.triggerType ? { triggerType: (0, index_js_1.normalizeScheduledJobTriggerType)(input.triggerType) } : {}),
+            ...(Object.prototype.hasOwnProperty.call(input, 'cronExpr') ? { cronExpr: input.cronExpr || undefined } : {}),
+            ...(Object.prototype.hasOwnProperty.call(input, 'runAt') ? { runAt: input.runAt || undefined } : {}),
+            ...(typeof input.promptTemplate === 'string' ? { promptTemplate: input.promptTemplate } : {}),
+            ...(typeof input.description === 'string' ? { description: input.description } : {}),
+            ...(typeof input.enabled === 'boolean' ? { enabled: input.enabled } : {}),
+            updatedAt: new Date().toISOString(),
+        };
+        this.db.prepare(`
+      UPDATE scheduled_jobs
+      SET route_type = ?, route_config = ?, execution_mode = ?, trigger_type = ?, cron_expr = ?, run_at = ?, prompt_template = ?,
+          description = ?, enabled = ?, updated_at = ?
+      WHERE id = ?
+    `).run(next.route.type, JSON.stringify(next.route), next.executionMode, next.triggerType, next.cronExpr || null, next.runAt || null, next.promptTemplate, next.description, next.enabled ? 1 : 0, next.updatedAt, jobId);
+        return this.getJob(jobId);
+    }
+    deleteJob(jobId) {
+        const result = this.db.prepare('DELETE FROM scheduled_jobs WHERE id = ?').run(jobId);
+        if (result.changes === 0) {
+            throw new Error(`Scheduled job not found: ${jobId}`);
+        }
+        return { deleted: true };
+    }
+    listRuns(jobId) {
+        const rows = this.db.prepare(`
+      SELECT id, job_id, status, triggered_at, started_at, finished_at, error, thread_id, run_id, platform_message_id, platform_message_ids_json, delivery_mode, delivery_status, delivery_error, last_bridge_event_at
+      FROM scheduled_job_runs
+      WHERE job_id = ?
+      ORDER BY triggered_at DESC
+    `).all(jobId);
+        return rows.map((row) => this.toScheduledJobRun(row));
+    }
+    createRun(jobId, status, input = {}) {
+        const id = `jobrun:${(0, node_crypto_1.randomUUID)()}`;
+        const triggeredAt = input.triggeredAt || new Date().toISOString();
+        const normalizedStatus = (0, index_js_1.normalizeScheduledJobRunStatus)(status);
+        this.db.prepare(`
+      INSERT INTO scheduled_job_runs (id, job_id, status, triggered_at, started_at, finished_at, error, thread_id, run_id, platform_message_id, platform_message_ids_json, delivery_mode, delivery_status, delivery_error, last_bridge_event_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, jobId, normalizedStatus, triggeredAt, input.startedAt || null, input.finishedAt || null, input.error || null, input.threadId || null, input.runId || null, input.platformMessageId || null, JSON.stringify(input.platformMessageIds || []), input.deliveryMode || null, input.deliveryStatus || null, input.deliveryError || null, input.lastBridgeEventAt || null);
+        this.updateJobStatus(jobId, {
+            lastRunAt: triggeredAt,
+            lastStatus: normalizedStatus,
+            lastError: input.error || '',
+        });
+        return this.getRun(id);
+    }
+    getRun(runId) {
+        const row = this.db.prepare(`
+      SELECT id, job_id, status, triggered_at, started_at, finished_at, error, thread_id, run_id, platform_message_id, platform_message_ids_json, delivery_mode, delivery_status, delivery_error, last_bridge_event_at
+      FROM scheduled_job_runs
+      WHERE id = ?
+    `).get(runId);
+        return row ? this.toScheduledJobRun(row) : undefined;
+    }
+    updateRun(runId, input) {
+        const existing = this.getRun(runId);
+        if (!existing) {
+            throw new Error(`Scheduled job run not found: ${runId}`);
+        }
+        const next = {
+            ...existing,
+            ...input,
+            ...(input.status ? { status: (0, index_js_1.normalizeScheduledJobRunStatus)(input.status) } : {}),
+        };
+        this.db.prepare(`
+      UPDATE scheduled_job_runs
+      SET status = ?, triggered_at = ?, started_at = ?, finished_at = ?, error = ?, thread_id = ?, run_id = ?, platform_message_id = ?, platform_message_ids_json = ?, delivery_mode = ?, delivery_status = ?, delivery_error = ?, last_bridge_event_at = ?
+      WHERE id = ?
+    `).run(next.status, next.triggeredAt, next.startedAt || null, next.finishedAt || null, next.error || null, next.threadId || null, next.runId || null, next.platformMessageId || null, JSON.stringify(next.platformMessageIds || []), next.deliveryMode || null, next.deliveryStatus || null, next.deliveryError || null, next.lastBridgeEventAt || null, runId);
+        if (input.status || Object.prototype.hasOwnProperty.call(input, 'error') || input.finishedAt || input.triggeredAt) {
+            this.updateJobStatus(existing.jobId, {
+                lastRunAt: next.triggeredAt,
+                lastStatus: next.status,
+                lastError: next.error || '',
+            });
+        }
+        return this.getRun(runId);
+    }
+    updateJobStatus(jobId, input) {
+        this.db.prepare(`
+      UPDATE scheduled_jobs
+      SET last_run_at = COALESCE(?, last_run_at),
+          last_status = COALESCE(?, last_status),
+          last_error = CASE WHEN ? IS NULL THEN last_error ELSE ? END,
+          enabled = CASE WHEN ? IS NULL THEN enabled ELSE ? END,
+          updated_at = ?
+      WHERE id = ?
+    `).run(input.lastRunAt || null, input.lastStatus || null, input.lastError == null ? null : input.lastError, input.lastError == null ? null : input.lastError, typeof input.enabled === 'boolean' ? (input.enabled ? 1 : 0) : null, typeof input.enabled === 'boolean' ? (input.enabled ? 1 : 0) : null, new Date().toISOString(), jobId);
+    }
+    toScheduledJob(row) {
+        const route = JSON.parse(row.route_config);
+        return {
+            id: row.id,
+            workspaceId: row.workspace_id,
+            platform: (0, index_js_1.normalizeChannelPlatform)(row.platform),
+            route,
+            executionMode: (0, index_js_1.normalizeScheduledJobExecutionMode)(row.execution_mode),
+            triggerType: (0, index_js_1.normalizeScheduledJobTriggerType)(row.trigger_type),
+            cronExpr: row.cron_expr || undefined,
+            runAt: row.run_at || undefined,
+            promptTemplate: row.prompt_template,
+            description: row.description,
+            enabled: Boolean(row.enabled),
+            concurrencyPolicy: row.concurrency_policy,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            lastRunAt: row.last_run_at || undefined,
+            lastStatus: row.last_status ? (0, index_js_1.normalizeScheduledJobRunStatus)(row.last_status) : undefined,
+            lastError: row.last_error || undefined,
+        };
+    }
+    toScheduledJobRun(row) {
+        return {
+            id: row.id,
+            jobId: row.job_id,
+            status: (0, index_js_1.normalizeScheduledJobRunStatus)(row.status),
+            triggeredAt: row.triggered_at,
+            startedAt: row.started_at || undefined,
+            finishedAt: row.finished_at || undefined,
+            error: row.error || undefined,
+            threadId: row.thread_id || undefined,
+            runId: row.run_id || undefined,
+            platformMessageId: row.platform_message_id || undefined,
+            platformMessageIds: (0, utils_js_1.parseJson)(row.platform_message_ids_json || '[]', []),
+            deliveryMode: row.delivery_mode || undefined,
+            deliveryStatus: row.delivery_status || undefined,
+            deliveryError: row.delivery_error || undefined,
+            lastBridgeEventAt: row.last_bridge_event_at || undefined,
+        };
+    }
+}
+exports.LocalSchedulerStore = LocalSchedulerStore;