@kafca/agentdock 0.1.41 → 0.1.43

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

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalThreadStore = void 0;
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("../../../../../packages/contracts/src/index.js");
+const desktop_js_1 = require("../../../../../shared/desktop.js");
+const workspace_thread_mappers_js_1 = require("../../thread/workspace-thread-mappers.js");
+const workspace_thread_id_js_1 = require("../../thread/workspace-thread-id.js");
+const utils_js_1 = require("./utils.js");
+class LocalThreadStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    listSummaries(workspaceId) {
+        const rows = this.db.prepare(`
+      SELECT id, workspace_id, session_id, bridge_session_key, title, agent_type, created_at, updated_at, history_count, excerpt, acp_session_id, acp_supports_load, agent_mode
+      FROM threads
+      WHERE workspace_id = ?
+      ORDER BY updated_at DESC
+    `).all(workspaceId);
+        return rows.map((row) => ({
+            id: row.id,
+            workspaceId: row.workspace_id,
+            title: row.title,
+            live: false,
+            updatedAt: row.updated_at,
+            createdAt: row.created_at,
+            historyCount: row.history_count,
+            excerpt: row.excerpt,
+            runId: undefined,
+            bridgeSessionKey: row.bridge_session_key,
+            agentType: row.agent_type,
+        }));
+    }
+    count(workspaceId) {
+        const row = this.db.prepare('SELECT COUNT(*) AS total FROM threads WHERE workspace_id = ?').get(workspaceId);
+        return Number(row?.total || 0);
+    }
+    create(workspaceId, title, agentType = desktop_js_1.LOCALCORE_ACP_AGENT_TYPE, agentMode = 'default') {
+        const sessionId = (0, node_crypto_1.randomUUID)();
+        const threadId = (0, workspace_thread_id_js_1.encodeThreadId)(workspaceId, sessionId);
+        const now = new Date().toISOString();
+        const bridgeSessionKey = `${desktop_js_1.LOCALCORE_ACP_AGENT_TYPE}:${workspaceId}:${sessionId}`;
+        this.db.prepare(`
+      INSERT INTO threads (id, workspace_id, session_id, bridge_session_key, title, agent_type, created_at, updated_at, history_count, excerpt, agent_mode)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, '', ?)
+    `).run(threadId, workspaceId, sessionId, bridgeSessionKey, title, agentType, now, now, agentMode || 'default');
+        return {
+            id: threadId,
+            workspaceId,
+            title,
+            live: false,
+            updatedAt: now,
+            createdAt: now,
+            historyCount: 0,
+            excerpt: '',
+            bridgeSessionKey,
+            agentType,
+            messages: [],
+            selectedKnowledgeBaseIds: [],
+            pendingPermissionRequest: null,
+        };
+    }
+    get(threadId, selectedKnowledgeBaseIds) {
+        const row = this.getRow(threadId);
+        if (!row) {
+            throw new Error(`Thread not found: ${threadId}`);
+        }
+        const messages = this.db.prepare(`
+      SELECT id, thread_id, role, content, tool_call_json, bridge_kind, bridge_status, timestamp, kind, seq
+      FROM messages
+      WHERE thread_id = ?
+      ORDER BY seq ASC
+    `).all(threadId);
+        return {
+            id: row.id,
+            workspaceId: row.workspace_id,
+            title: row.title,
+            live: false,
+            updatedAt: row.updated_at,
+            createdAt: row.created_at,
+            historyCount: row.history_count,
+            excerpt: row.excerpt,
+            bridgeSessionKey: row.bridge_session_key,
+            agentType: row.agent_type,
+            messages: messages.map((message) => ({
+                id: message.id,
+                role: message.role,
+                content: message.content,
+                toolCall: (0, utils_js_1.parseJson)(message.tool_call_json || 'null', null) || undefined,
+                bridgeKind: (0, utils_js_1.normalizeBridgeKind)(message.bridge_kind),
+                bridgeStatus: (0, utils_js_1.normalizeBridgeStatus)(message.bridge_status),
+                timestamp: message.timestamp,
+                kind: message.kind,
+            })),
+            selectedKnowledgeBaseIds,
+            pendingPermissionRequest: null,
+        };
+    }
+    rename(threadId, title) {
+        const now = new Date().toISOString();
+        this.db.prepare('UPDATE threads SET title = ?, updated_at = ? WHERE id = ?').run(title, now, threadId);
+    }
+    delete(threadId) {
+        this.db.prepare('DELETE FROM threads WHERE id = ?').run(threadId);
+    }
+    appendMessage(threadId, role, content, kind, toolCall, bridgeKind, bridgeStatus) {
+        const timestamp = new Date().toISOString();
+        const nextSequenceRow = this.db.prepare('SELECT COALESCE(MAX(seq), -1) + 1 AS next_seq FROM messages WHERE thread_id = ?').get(threadId);
+        const nextSeq = Number(nextSequenceRow?.next_seq || 0);
+        const id = `${timestamp}-${role}-${nextSeq}`;
+        const excerpt = (0, workspace_thread_mappers_js_1.normalizeMessageContent)(content);
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.db.prepare(`
+        INSERT INTO messages (id, thread_id, role, content, tool_call_json, bridge_kind, bridge_status, timestamp, kind, seq)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, threadId, role, content, toolCall ? JSON.stringify(toolCall) : null, bridgeKind || null, bridgeStatus || null, timestamp, kind, nextSeq);
+            this.db.prepare(`
+        UPDATE threads
+        SET updated_at = ?, history_count = history_count + 1, excerpt = ?
+        WHERE id = ?
+      `).run(timestamp, excerpt, threadId);
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+        return { id, timestamp };
+    }
+    upsertMessage(threadId, id, role, content, kind, toolCall, bridgeKind, bridgeStatus) {
+        const timestamp = new Date().toISOString();
+        const excerpt = (0, workspace_thread_mappers_js_1.normalizeMessageContent)(content);
+        const existing = this.db.prepare('SELECT id FROM messages WHERE id = ? AND thread_id = ?').get(id, threadId);
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            if (existing) {
+                this.db.prepare(`
+          UPDATE messages
+          SET content = ?, tool_call_json = ?, bridge_kind = ?, bridge_status = ?, timestamp = ?, kind = ?
+          WHERE id = ? AND thread_id = ?
+        `).run(content, toolCall ? JSON.stringify(toolCall) : null, bridgeKind || null, bridgeStatus || null, timestamp, kind, id, threadId);
+            }
+            else {
+                const nextSequenceRow = this.db.prepare('SELECT COALESCE(MAX(seq), -1) + 1 AS next_seq FROM messages WHERE thread_id = ?').get(threadId);
+                const nextSeq = Number(nextSequenceRow?.next_seq || 0);
+                this.db.prepare(`
+          INSERT INTO messages (id, thread_id, role, content, tool_call_json, bridge_kind, bridge_status, timestamp, kind, seq)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(id, threadId, role, content, toolCall ? JSON.stringify(toolCall) : null, bridgeKind || null, bridgeStatus || null, timestamp, kind, nextSeq);
+                this.db.prepare(`
+          UPDATE threads
+          SET history_count = history_count + 1
+          WHERE id = ?
+        `).run(threadId);
+            }
+            this.db.prepare(`
+        UPDATE threads
+        SET updated_at = ?, excerpt = ?
+        WHERE id = ?
+      `).run(timestamp, excerpt, threadId);
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+        return { id, timestamp };
+    }
+    updateRun(runId, threadId, status) {
+        const now = new Date().toISOString();
+        const normalizedStatus = (0, index_js_1.normalizeRunStatus)(status);
+        const existing = this.db.prepare('SELECT id FROM runs WHERE id = ?').get(runId);
+        if (existing) {
+            this.db.prepare('UPDATE runs SET status = ?, updated_at = ? WHERE id = ?').run(normalizedStatus, now, runId);
+            return;
+        }
+        this.db.prepare(`
+      INSERT INTO runs (id, thread_id, status, started_at, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(runId, threadId, normalizedStatus, now, now);
+    }
+    getLatestRunForThread(threadId) {
+        const row = this.db.prepare(`
+      SELECT id, thread_id, status, started_at, updated_at
+      FROM runs
+      WHERE thread_id = ?
+      ORDER BY updated_at DESC
+      LIMIT 1
+    `).get(threadId);
+        return row ? { ...row, status: (0, index_js_1.normalizeRunStatus)(row.status) } : undefined;
+    }
+    getRun(runId) {
+        const row = this.db.prepare(`
+      SELECT id, thread_id, status, started_at, updated_at
+      FROM runs
+      WHERE id = ?
+    `).get(runId);
+        return row ? { ...row, status: (0, index_js_1.normalizeRunStatus)(row.status) } : undefined;
+    }
+    getRow(threadId) {
+        return this.db.prepare(`
+      SELECT id, workspace_id, session_id, bridge_session_key, title, agent_type, created_at, updated_at, history_count, excerpt, acp_session_id, acp_supports_load, agent_mode
+      FROM threads
+      WHERE id = ?
+    `).get(threadId);
+    }
+    updateAgentMode(threadId, mode) {
+        this.db.prepare(`
+      UPDATE threads
+      SET agent_mode = ?, updated_at = ?
+      WHERE id = ?
+    `).run(mode, new Date().toISOString(), threadId);
+    }
+    updateAgentType(threadId, agentType) {
+        this.db.prepare(`
+      UPDATE threads
+      SET agent_type = ?, acp_session_id = NULL, acp_supports_load = 0, updated_at = ?
+      WHERE id = ?
+    `).run(agentType, new Date().toISOString(), threadId);
+    }
+    updateSession(threadId, sessionId, supportsLoad) {
+        this.db.prepare(`
+      UPDATE threads
+      SET acp_session_id = ?, acp_supports_load = ?, updated_at = COALESCE(updated_at, ?)
+      WHERE id = ?
+    `).run(sessionId, supportsLoad ? 1 : 0, new Date().toISOString(), threadId);
+    }
+}
+exports.LocalThreadStore = LocalThreadStore;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJson = parseJson;
+exports.normalizeBridgeKind = normalizeBridgeKind;
+exports.normalizeBridgeStatus = normalizeBridgeStatus;
+exports.defaultPermissions = defaultPermissions;
+exports.redactSecrets = redactSecrets;
+function parseJson(value, fallback) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return fallback;
+    }
+}
+function normalizeBridgeKind(value) {
+    switch (value) {
+        case 'assistant':
+        case 'thought':
+        case 'plan':
+        case 'tool':
+        case 'status':
+        case 'permission':
+            return value;
+        default:
+            return undefined;
+    }
+}
+function normalizeBridgeStatus(value) {
+    return value === 'awaiting_input' ? value : undefined;
+}
+function defaultPermissions() {
+    return {
+        'workspace.read': 'allow',
+        'workspace.write': 'ask',
+        'command.execute': 'ask',
+        'network.access': 'ask',
+        'secrets.access': 'deny',
+        'git.modify': 'ask',
+    };
+}
+function redactSecrets(value) {
+    return value
+        .replace(/\b(sk-[A-Za-z0-9_-]{12,})\b/g, '[REDACTED_SECRET]')
+        .replace(/\b([A-Za-z0-9_]*TOKEN[A-Za-z0-9_]*|[A-Za-z0-9_]*SECRET[A-Za-z0-9_]*|[A-Za-z0-9_]*KEY[A-Za-z0-9_]*)=([^\s]+)/gi, '$1=[REDACTED_SECRET]')
+        .replace(/\b(Bearer\s+)[A-Za-z0-9._-]+/gi, '$1[REDACTED_SECRET]');
+}

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

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalWorkspaceRegistryStore = void 0;
+const utils_js_1 = require("./utils.js");
+class LocalWorkspaceRegistryStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    list() {
+        const rows = this.db.prepare(`
+      SELECT id, display_name, path, device_id, default_runtime_id, git_json, health_json, metadata_json, created_at, updated_at, last_opened_at
+      FROM workspace_registry
+      ORDER BY display_name ASC
+    `).all();
+        return rows.map((row) => this.toEntry(row));
+    }
+    get(workspaceId) {
+        const row = this.db.prepare(`
+      SELECT id, display_name, path, device_id, default_runtime_id, git_json, health_json, metadata_json, created_at, updated_at, last_opened_at
+      FROM workspace_registry
+      WHERE id = ?
+    `).get(workspaceId);
+        return row ? this.toEntry(row) : undefined;
+    }
+    upsert(input) {
+        const id = input.workspaceId || input.displayName;
+        const now = new Date().toISOString();
+        const existing = this.get(id);
+        const health = input.health || existing?.health || {
+            status: 'unknown',
+            summary: 'Workspace health has not been checked.',
+            issues: [],
+        };
+        this.db.prepare(`
+      INSERT INTO workspace_registry (
+        id, display_name, path, device_id, default_runtime_id, git_json, health_json, metadata_json, created_at, updated_at, last_opened_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        display_name = excluded.display_name,
+        path = excluded.path,
+        device_id = excluded.device_id,
+        default_runtime_id = excluded.default_runtime_id,
+        git_json = excluded.git_json,
+        health_json = excluded.health_json,
+        metadata_json = excluded.metadata_json,
+        updated_at = excluded.updated_at
+    `).run(id, input.displayName, input.path, input.deviceId, input.defaultRuntimeId || null, JSON.stringify(input.git || existing?.git || {}), JSON.stringify(health), JSON.stringify(input.metadata || existing?.metadata || {}), existing?.createdAt || now, now, existing?.lastOpenedAt || null);
+        return this.get(id);
+    }
+    update(workspaceId, input) {
+        const existing = this.get(workspaceId);
+        if (!existing) {
+            throw new Error(`Workspace not found: ${workspaceId}`);
+        }
+        return this.upsert({
+            workspaceId,
+            displayName: input.displayName || existing.displayName,
+            path: input.path || existing.path,
+            deviceId: existing.deviceId,
+            defaultRuntimeId: input.defaultRuntimeId === null ? undefined : input.defaultRuntimeId || existing.defaultRuntimeId,
+            git: existing.git,
+            health: existing.health,
+            metadata: input.metadata || existing.metadata,
+        });
+    }
+    delete(workspaceId) {
+        this.db.prepare('DELETE FROM workspace_registry WHERE id = ?').run(workspaceId);
+        return { deleted: true };
+    }
+    touch(workspaceId) {
+        this.db.prepare('UPDATE workspace_registry SET last_opened_at = ?, updated_at = ? WHERE id = ?')
+            .run(new Date().toISOString(), new Date().toISOString(), workspaceId);
+    }
+    toEntry(row) {
+        const activeTaskCount = Number(this.db.prepare(`
+      SELECT COUNT(*) AS total
+      FROM agent_tasks
+      WHERE workspace_id = ? AND status IN ('created', 'queued', 'running', 'waiting_for_user')
+    `).get(row.id)?.total || 0);
+        const recentTaskRows = this.db.prepare(`
+      SELECT id
+      FROM agent_tasks
+      WHERE workspace_id = ?
+      ORDER BY updated_at DESC
+      LIMIT 8
+    `).all(row.id);
+        return {
+            workspaceId: row.id,
+            displayName: row.display_name,
+            path: row.path,
+            deviceId: row.device_id,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            lastOpenedAt: row.last_opened_at || undefined,
+            defaultRuntimeId: row.default_runtime_id || undefined,
+            git: (0, utils_js_1.parseJson)(row.git_json, { isRepo: false }),
+            health: (0, utils_js_1.parseJson)(row.health_json, {
+                status: 'unknown',
+                summary: 'Workspace health has not been checked.',
+                issues: [],
+            }),
+            activeTaskCount,
+            recentTaskIds: recentTaskRows.map((item) => item.id),
+            metadata: (0, utils_js_1.parseJson)(row.metadata_json, {}),
+        };
+    }
+}
+exports.LocalWorkspaceRegistryStore = LocalWorkspaceRegistryStore;

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

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationConversationExecutor = void 0;
+exports.renderMonitorPrompt = renderMonitorPrompt;
+const scheduled_bridge_session_js_1 = require("../scheduler/scheduled-bridge-session.js");
+const scheduled_job_route_js_1 = require("../scheduler/scheduled-job-route.js");
+const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'interrupted']);
+const MONITOR_RUN_PERMISSION_MODE = 'bypassPermissions';
+class AutomationConversationExecutor {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async execute(monitor, event, timeoutMs = 15 * 60 * 1000) {
+        const workspaceRouter = this.options.getWorkspaceRouter();
+        const threadId = await this.resolveThread(monitor);
+        const prompt = renderMonitorPrompt(monitor.promptTemplate, event, monitor);
+        const channelRuntime = monitor.platform === 'local' ? undefined : this.options.getChannelRuntime(monitor.platform);
+        const bridge = channelRuntime
+            ? await scheduled_bridge_session_js_1.ScheduledBridgeSession.open({
+                target: {
+                    id: monitor.id,
+                    workspaceId: monitor.workspaceId,
+                    platform: monitor.platform,
+                    route: monitor.route,
+                    title: monitor.title,
+                    promptTemplate: monitor.promptTemplate,
+                },
+                threadId,
+                workspaceRouter,
+                getChannelRuntime: () => channelRuntime,
+                noticeIcon: monitor.sourceType === 'stock.quote' ? '📈' : '🔔',
+                noticeTitle: monitor.title,
+            })
+            : undefined;
+        try {
+            const sendResult = await workspaceRouter.sendThreadMessage(threadId, prompt, {
+                permissionMode: MONITOR_RUN_PERMISSION_MODE,
+                runtimeEnv: this.buildRuntimeEnv(monitor),
+            });
+            await this.waitForRun(sendResult.runId, timeoutMs);
+            const thread = await workspaceRouter.getThread(threadId);
+            const replyText = [...thread.messages]
+                .reverse()
+                .find((message) => message.role === 'assistant' && message.kind === 'final')
+                ?.content;
+            return {
+                threadId,
+                runId: sendResult.runId,
+                replyText,
+                deliveryMode: bridge ? 'bridge-stream' : 'thread-only',
+                deliveryStatus: 'succeeded',
+                lastBridgeEventAt: bridge ? new Date().toISOString() : undefined,
+            };
+        }
+        finally {
+            await bridge?.close();
+        }
+    }
+    async resolveThread(monitor) {
+        const workspaceRouter = this.options.getWorkspaceRouter();
+        if (monitor.executionMode === 'same-thread') {
+            const binding = this.options.store.getPlatformThreadBinding(monitor.workspaceId, monitor.route.channelId, monitor.route.participantId || '', monitor.platform);
+            if (binding?.thread_id && await this.threadExists(binding.thread_id)) {
+                return binding.thread_id;
+            }
+            if (monitor.route.threadId && await this.threadExists(monitor.route.threadId)) {
+                return monitor.route.threadId;
+            }
+        }
+        const title = monitor.platform === 'local'
+            ? `[Monitor] ${monitor.title}`
+            : `[Monitor:${(0, scheduled_job_route_js_1.getChannelPlatformBase)(monitor.platform) || monitor.platform}] ${monitor.title}`;
+        const existing = (await workspaceRouter.listThreads(monitor.workspaceId))
+            .find((thread) => thread.title === title);
+        if (existing) {
+            return existing.id;
+        }
+        const created = await workspaceRouter.createThread(monitor.workspaceId, title);
+        return created.id;
+    }
+    async threadExists(threadId) {
+        try {
+            await this.options.getWorkspaceRouter().getThread(threadId);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    buildRuntimeEnv(monitor) {
+        const basePlatform = (0, scheduled_job_route_js_1.getChannelPlatformBase)(monitor.platform);
+        const env = {};
+        if (basePlatform && basePlatform !== 'local') {
+            env.LOCAL_AI_PLATFORM = basePlatform;
+            env.LOCAL_AI_ROUTE_TYPE = (0, scheduled_job_route_js_1.routeTypeForPlatform)(monitor.platform);
+        }
+        const instanceId = monitor.route.instanceId || (0, scheduled_job_route_js_1.getChannelPlatformInstanceId)(monitor.platform);
+        if (instanceId) {
+            env.LOCAL_AI_PLATFORM_INSTANCE_ID = instanceId;
+        }
+        if (monitor.route.channelId) {
+            env.LOCAL_AI_CHAT_ID = monitor.route.channelId;
+        }
+        if (monitor.route.participantId) {
+            env.LOCAL_AI_PLATFORM_USER_ID = monitor.route.participantId;
+        }
+        return env;
+    }
+    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(`Monitor run finished with status ${run.status}`);
+                }
+                return run;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 300));
+        }
+        throw new Error(`Timed out waiting for monitor run ${runId}`);
+    }
+}
+exports.AutomationConversationExecutor = AutomationConversationExecutor;
+function renderMonitorPrompt(template, event, monitor) {
+    const values = {
+        title: monitor.title,
+        sourceType: event.sourceType,
+        subject: event.subject,
+        summary: event.summary || '',
+        timestamp: event.occurredAt,
+        ...event.payload,
+    };
+    return String(template || '').replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (_match, key) => String(values[key] ?? ''));
+}

package/dist-electron/services/local-ai-core/src/automation/automation-monitor-repository.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationMonitorRepository = void 0;
+class AutomationMonitorRepository {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    list(workspaceId) {
+        return this.store.listAutomationMonitors(workspaceId);
+    }
+    get(monitorId) {
+        return this.store.getAutomationMonitor(monitorId);
+    }
+    create(input) {
+        return this.store.createAutomationMonitor(input);
+    }
+    update(monitorId, input) {
+        return this.store.updateAutomationMonitor(monitorId, input);
+    }
+    updateState(monitorId, input) {
+        return this.store.updateAutomationMonitorState(monitorId, input);
+    }
+    delete(monitorId) {
+        return this.store.deleteAutomationMonitor(monitorId);
+    }
+    listRuns(monitorId) {
+        return this.store.listAutomationMonitorRuns(monitorId);
+    }
+    createRun(monitorId, status, input = {}) {
+        return this.store.createAutomationMonitorRun(monitorId, status, input);
+    }
+    updateRun(runId, input) {
+        return this.store.updateAutomationMonitorRun(runId, input);
+    }
+    getPlatformThreadBindingByThreadId(threadId) {
+        return this.store.getPlatformThreadBindingByThreadId(threadId);
+    }
+    toScheduledLike(monitor) {
+        return {
+            id: monitor.id,
+            workspaceId: monitor.workspaceId,
+            platform: monitor.platform,
+            route: monitor.route,
+            executionMode: monitor.executionMode,
+            triggerType: 'once',
+            promptTemplate: monitor.promptTemplate,
+            description: monitor.title,
+            enabled: monitor.enabled,
+            concurrencyPolicy: monitor.concurrencyPolicy,
+            createdAt: monitor.createdAt,
+            updatedAt: monitor.updatedAt,
+        };
+    }
+}
+exports.AutomationMonitorRepository = AutomationMonitorRepository;