@kafca/agentdock 0.1.42 → 0.1.44

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

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalAgentTaskStore = void 0;
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("../../../../../packages/contracts/src/index.js");
+const utils_js_1 = require("./utils.js");
+class LocalAgentTaskStore {
+    db;
+    createAuditEvent;
+    constructor(db, createAuditEvent) {
+        this.db = db;
+        this.createAuditEvent = createAuditEvent;
+    }
+    create(input) {
+        const id = `task:${(0, node_crypto_1.randomUUID)()}`;
+        const now = new Date().toISOString();
+        const status = (0, index_js_1.normalizeAgentTaskStatus)(input.status);
+        const timeline = [{
+                id: `timeline:${(0, node_crypto_1.randomUUID)()}`,
+                type: 'status_change',
+                title: `Task ${status}`,
+                status,
+                timestamp: now,
+            }];
+        this.db.prepare(`
+      INSERT INTO agent_tasks (
+        id, workspace_id, device_id, runtime_id, thread_id, run_id, title, prompt, status, created_at, updated_at, queued_at,
+        started_at, completed_at, summary, error, timeline_json, logs_json, artifacts_json, approval_ids_json, metadata_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL, ?, '[]', '[]', '[]', ?)
+    `).run(id, input.workspaceId, input.deviceId, input.runtimeId, input.threadId || null, input.runId || null, input.title, input.prompt ? (0, utils_js_1.redactSecrets)(input.prompt) : null, status, now, now, status === 'queued' ? now : null, status === 'running' ? now : null, JSON.stringify(timeline), JSON.stringify(input.metadata || {}));
+        const task = this.get(id);
+        this.createAuditEvent({
+            type: 'task.created',
+            workspaceId: task.workspaceId,
+            taskId: task.taskId,
+            actor: 'local',
+            summary: `Task created: ${task.title}`,
+            metadata: { runtimeId: task.runtimeId, threadId: task.threadId, runId: task.runId },
+        });
+        return task;
+    }
+    list(query = {}) {
+        const predicates = [];
+        const params = [];
+        if (query.workspaceId) {
+            predicates.push('workspace_id = ?');
+            params.push(query.workspaceId);
+        }
+        if (query.runtimeId) {
+            predicates.push('runtime_id = ?');
+            params.push(query.runtimeId);
+        }
+        if (query.status) {
+            const statuses = (Array.isArray(query.status) ? query.status : [query.status]).map((status) => (0, index_js_1.normalizeAgentTaskStatus)(status));
+            predicates.push(`status IN (${statuses.map(() => '?').join(', ')})`);
+            params.push(...statuses);
+        }
+        const limit = Math.max(1, Math.min(Number(query.limit || 50), 100));
+        const where = predicates.length ? `WHERE ${predicates.join(' AND ')}` : '';
+        const rows = this.db.prepare(`
+      SELECT *
+      FROM agent_tasks
+      ${where}
+      ORDER BY updated_at DESC
+      LIMIT ?
+    `).all(...params, limit);
+        return { tasks: rows.map((row) => this.toAgentTask(row)) };
+    }
+    get(taskId) {
+        const row = this.db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
+        return row ? this.toAgentTask(row) : undefined;
+    }
+    getByRunId(runId) {
+        const row = this.db.prepare('SELECT * FROM agent_tasks WHERE run_id = ? ORDER BY updated_at DESC LIMIT 1').get(runId);
+        return row ? this.toAgentTask(row) : undefined;
+    }
+    update(taskId, input) {
+        const existing = this.get(taskId);
+        if (!existing) {
+            throw new Error(`Task not found: ${taskId}`);
+        }
+        const now = new Date().toISOString();
+        const nextStatus = input.status ? (0, index_js_1.normalizeAgentTaskStatus)(input.status) : existing.status;
+        const timeline = [...existing.timeline];
+        const logs = [...existing.logs];
+        const artifacts = [...existing.artifacts];
+        const approvalIds = [...existing.approvalIds];
+        if (input.status && nextStatus !== existing.status) {
+            timeline.push({
+                id: `timeline:${(0, node_crypto_1.randomUUID)()}`,
+                type: 'status_change',
+                title: `Task ${nextStatus}`,
+                status: nextStatus,
+                timestamp: now,
+            });
+        }
+        if (input.timelineItem) {
+            timeline.push({
+                id: input.timelineItem.id || `timeline:${(0, node_crypto_1.randomUUID)()}`,
+                timestamp: input.timelineItem.timestamp || now,
+                ...input.timelineItem,
+            });
+        }
+        if (input.log) {
+            logs.push({
+                id: input.log.id || `log:${(0, node_crypto_1.randomUUID)()}`,
+                timestamp: input.log.timestamp || now,
+                ...input.log,
+                message: (0, utils_js_1.redactSecrets)(input.log.message),
+            });
+        }
+        if (input.artifact) {
+            artifacts.push({
+                id: input.artifact.id || `artifact:${(0, node_crypto_1.randomUUID)()}`,
+                ...input.artifact,
+            });
+        }
+        if (input.approvalId && !approvalIds.includes(input.approvalId)) {
+            approvalIds.push(input.approvalId);
+        }
+        this.db.prepare(`
+      UPDATE agent_tasks
+      SET status = ?, thread_id = ?, run_id = ?, title = ?, updated_at = ?, queued_at = ?, started_at = ?, completed_at = ?,
+          summary = ?, error = ?, timeline_json = ?, logs_json = ?, artifacts_json = ?, approval_ids_json = ?, metadata_json = ?
+      WHERE id = ?
+    `).run(nextStatus, input.threadId || existing.threadId || null, input.runId || existing.runId || null, input.title || existing.title, now, existing.queuedAt || (nextStatus === 'queued' ? now : null), existing.startedAt || (nextStatus === 'running' ? now : null), existing.completedAt || (['completed', 'failed', 'cancelled'].includes(nextStatus) ? now : null), input.summary ?? existing.summary ?? null, input.error === null ? null : input.error ?? existing.error ?? null, JSON.stringify(timeline), JSON.stringify(logs), JSON.stringify(artifacts), JSON.stringify(approvalIds), JSON.stringify(input.metadata || existing.metadata || {}), taskId);
+        const task = this.get(taskId);
+        if (input.status && nextStatus !== existing.status) {
+            this.createAuditEvent({
+                type: 'task.updated',
+                workspaceId: task.workspaceId,
+                taskId: task.taskId,
+                actor: 'local',
+                summary: `Task status changed to ${nextStatus}.`,
+                metadata: { previousStatus: existing.status, status: nextStatus, runId: task.runId },
+            });
+        }
+        return task;
+    }
+    toAgentTask(row) {
+        return {
+            taskId: row.id,
+            workspaceId: row.workspace_id,
+            deviceId: row.device_id,
+            runtimeId: row.runtime_id,
+            threadId: row.thread_id || undefined,
+            runId: row.run_id || undefined,
+            title: row.title,
+            prompt: row.prompt || undefined,
+            status: (0, index_js_1.normalizeAgentTaskStatus)(row.status),
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            queuedAt: row.queued_at || undefined,
+            startedAt: row.started_at || undefined,
+            completedAt: row.completed_at || undefined,
+            summary: row.summary || undefined,
+            error: row.error || undefined,
+            timeline: (0, utils_js_1.parseJson)(row.timeline_json, []),
+            logs: (0, utils_js_1.parseJson)(row.logs_json, []),
+            artifacts: (0, utils_js_1.parseJson)(row.artifacts_json, []),
+            approvalIds: (0, utils_js_1.parseJson)(row.approval_ids_json, []),
+            metadata: (0, utils_js_1.parseJson)(row.metadata_json, {}),
+        };
+    }
+}
+exports.LocalAgentTaskStore = LocalAgentTaskStore;

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

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalAutomationMonitorStore = void 0;
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("../../../../../packages/contracts/src/index.js");
+class LocalAutomationMonitorStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    list(workspaceId) {
+        const query = workspaceId
+            ? `
+        SELECT id, workspace_id, title, source_type, source_config_json, condition_json, prompt_template, platform, route_type, route_config,
+               execution_mode, enabled, cooldown_ms, concurrency_policy, last_state_json, created_at, updated_at, last_triggered_at, last_status, last_error
+        FROM automation_monitors
+        WHERE workspace_id = ?
+        ORDER BY updated_at DESC
+      `
+            : `
+        SELECT id, workspace_id, title, source_type, source_config_json, condition_json, prompt_template, platform, route_type, route_config,
+               execution_mode, enabled, cooldown_ms, concurrency_policy, last_state_json, created_at, updated_at, last_triggered_at, last_status, last_error
+        FROM automation_monitors
+        ORDER BY updated_at DESC
+      `;
+        const rows = this.db.prepare(query).all(...(workspaceId ? [workspaceId] : []));
+        return rows.map((row) => this.toMonitor(row));
+    }
+    get(monitorId) {
+        const row = this.db.prepare(`
+      SELECT id, workspace_id, title, source_type, source_config_json, condition_json, prompt_template, platform, route_type, route_config,
+             execution_mode, enabled, cooldown_ms, concurrency_policy, last_state_json, created_at, updated_at, last_triggered_at, last_status, last_error
+      FROM automation_monitors
+      WHERE id = ?
+    `).get(monitorId);
+        return row ? this.toMonitor(row) : undefined;
+    }
+    create(input) {
+        const title = String(input.title || '').trim();
+        if (!title)
+            throw new Error('Automation monitor title is required.');
+        const sourceType = String(input.sourceType || '').trim();
+        if (!sourceType)
+            throw new Error('Automation monitor source type is required.');
+        const condition = {
+            ...input.condition,
+            metric: String(input.condition?.metric || '').trim(),
+            operator: (0, index_js_1.normalizeAutomationMonitorConditionOperator)(input.condition?.operator),
+        };
+        if (!condition.metric)
+            throw new Error('Automation monitor condition metric is required.');
+        const id = this.createMonitorId();
+        const now = new Date().toISOString();
+        this.db.prepare(`
+      INSERT INTO automation_monitors (
+        id, workspace_id, title, source_type, source_config_json, condition_json, prompt_template, platform, route_type, route_config,
+        execution_mode, enabled, cooldown_ms, concurrency_policy, last_state_json, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'skip_if_running', ?, ?, ?)
+    `).run(id, input.workspaceId, title, sourceType, JSON.stringify(input.sourceConfig || {}), JSON.stringify(condition), input.promptTemplate, (0, index_js_1.normalizeChannelPlatform)(input.platform), input.route.type, JSON.stringify(input.route), (0, index_js_1.normalizeScheduledJobExecutionMode)(input.executionMode, 'side-thread'), input.enabled === false ? 0 : 1, Math.max(0, Number(input.cooldownMs ?? 15 * 60 * 1000)), null, now, now);
+        return this.get(id);
+    }
+    update(monitorId, input) {
+        const existing = this.get(monitorId);
+        if (!existing)
+            throw new Error(`Automation monitor not found: ${monitorId}`);
+        const nextCondition = input.condition
+            ? {
+                ...input.condition,
+                metric: String(input.condition.metric || '').trim(),
+                operator: (0, index_js_1.normalizeAutomationMonitorConditionOperator)(input.condition.operator),
+            }
+            : existing.condition;
+        const next = {
+            ...existing,
+            ...(typeof input.title === 'string' ? { title: input.title.trim() } : {}),
+            ...(input.sourceConfig ? { sourceConfig: input.sourceConfig } : {}),
+            condition: nextCondition,
+            ...(typeof input.promptTemplate === 'string' ? { promptTemplate: input.promptTemplate } : {}),
+            ...(input.route ? { route: input.route } : {}),
+            ...(input.executionMode ? { executionMode: (0, index_js_1.normalizeScheduledJobExecutionMode)(input.executionMode, 'side-thread') } : {}),
+            ...(typeof input.enabled === 'boolean' ? { enabled: input.enabled } : {}),
+            ...(typeof input.cooldownMs === 'number' ? { cooldownMs: Math.max(0, input.cooldownMs) } : {}),
+            updatedAt: new Date().toISOString(),
+        };
+        if (!next.title)
+            throw new Error('Automation monitor title is required.');
+        this.db.prepare(`
+      UPDATE automation_monitors
+      SET title = ?, source_config_json = ?, condition_json = ?, prompt_template = ?, route_type = ?, route_config = ?,
+          execution_mode = ?, enabled = ?, cooldown_ms = ?, updated_at = ?
+      WHERE id = ?
+    `).run(next.title, JSON.stringify(next.sourceConfig || {}), JSON.stringify(next.condition), next.promptTemplate, next.route.type, JSON.stringify(next.route), next.executionMode, next.enabled ? 1 : 0, next.cooldownMs, next.updatedAt, monitorId);
+        return this.get(monitorId);
+    }
+    updateState(monitorId, input) {
+        this.db.prepare(`
+      UPDATE automation_monitors
+      SET last_state_json = CASE WHEN ? IS NULL THEN last_state_json ELSE ? END,
+          last_triggered_at = COALESCE(?, last_triggered_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.lastState == null ? null : JSON.stringify(input.lastState), input.lastState == null ? null : JSON.stringify(input.lastState), input.lastTriggeredAt || 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(), monitorId);
+    }
+    delete(monitorId) {
+        const result = this.db.prepare('DELETE FROM automation_monitors WHERE id = ?').run(monitorId);
+        if (result.changes === 0)
+            throw new Error(`Automation monitor not found: ${monitorId}`);
+        return { deleted: true };
+    }
+    listRuns(monitorId) {
+        const rows = this.db.prepare(`
+      SELECT id, monitor_id, status, triggered_at, started_at, finished_at, error, event_snapshot_json, thread_id, run_id, delivery_mode, delivery_status, delivery_error, last_bridge_event_at
+      FROM automation_monitor_runs
+      WHERE monitor_id = ?
+      ORDER BY triggered_at DESC
+    `).all(monitorId);
+        return rows.map((row) => this.toRun(row));
+    }
+    createRun(monitorId, status, input = {}) {
+        const id = `monitorrun:${(0, node_crypto_1.randomUUID)()}`;
+        const triggeredAt = input.triggeredAt || new Date().toISOString();
+        const normalizedStatus = (0, index_js_1.normalizeAutomationMonitorStatus)(status);
+        this.db.prepare(`
+      INSERT INTO automation_monitor_runs (id, monitor_id, status, triggered_at, started_at, finished_at, error, event_snapshot_json, thread_id, run_id, delivery_mode, delivery_status, delivery_error, last_bridge_event_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, monitorId, normalizedStatus, triggeredAt, input.startedAt || null, input.finishedAt || null, input.error || null, input.eventSnapshot ? JSON.stringify(input.eventSnapshot) : null, input.threadId || null, input.runId || null, input.deliveryMode || null, input.deliveryStatus || null, input.deliveryError || null, input.lastBridgeEventAt || null);
+        this.updateState(monitorId, {
+            lastTriggeredAt: triggeredAt,
+            lastStatus: normalizedStatus,
+            lastError: input.error || '',
+        });
+        return this.getRun(id);
+    }
+    getRun(runId) {
+        const row = this.db.prepare(`
+      SELECT id, monitor_id, status, triggered_at, started_at, finished_at, error, event_snapshot_json, thread_id, run_id, delivery_mode, delivery_status, delivery_error, last_bridge_event_at
+      FROM automation_monitor_runs
+      WHERE id = ?
+    `).get(runId);
+        return row ? this.toRun(row) : undefined;
+    }
+    updateRun(runId, input) {
+        const existing = this.getRun(runId);
+        if (!existing)
+            throw new Error(`Automation monitor run not found: ${runId}`);
+        const next = {
+            ...existing,
+            ...input,
+            ...(input.status ? { status: (0, index_js_1.normalizeAutomationMonitorStatus)(input.status) } : {}),
+        };
+        this.db.prepare(`
+      UPDATE automation_monitor_runs
+      SET status = ?, triggered_at = ?, started_at = ?, finished_at = ?, error = ?, event_snapshot_json = ?, thread_id = ?, run_id = ?, 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.eventSnapshot ? JSON.stringify(next.eventSnapshot) : null, next.threadId || null, next.runId || null, 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.updateState(existing.monitorId, {
+                lastTriggeredAt: next.triggeredAt,
+                lastStatus: next.status,
+                lastError: next.error || '',
+            });
+        }
+        return this.getRun(runId);
+    }
+    toMonitor(row) {
+        const condition = parseJson(row.condition_json, {});
+        return {
+            id: row.id,
+            workspaceId: row.workspace_id,
+            title: row.title,
+            sourceType: row.source_type,
+            sourceConfig: parseJson(row.source_config_json || '{}', {}),
+            condition: {
+                ...condition,
+                operator: (0, index_js_1.normalizeAutomationMonitorConditionOperator)(condition.operator),
+            },
+            promptTemplate: row.prompt_template,
+            platform: (0, index_js_1.normalizeChannelPlatform)(row.platform),
+            route: JSON.parse(row.route_config),
+            executionMode: (0, index_js_1.normalizeScheduledJobExecutionMode)(row.execution_mode, 'side-thread'),
+            enabled: Boolean(row.enabled),
+            cooldownMs: Number(row.cooldown_ms || 0),
+            concurrencyPolicy: row.concurrency_policy,
+            lastState: row.last_state_json ? parseJson(row.last_state_json, {}) : undefined,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            lastTriggeredAt: row.last_triggered_at || undefined,
+            lastStatus: row.last_status ? (0, index_js_1.normalizeAutomationMonitorStatus)(row.last_status) : undefined,
+            lastError: row.last_error || undefined,
+        };
+    }
+    toRun(row) {
+        return {
+            id: row.id,
+            monitorId: row.monitor_id,
+            status: (0, index_js_1.normalizeAutomationMonitorStatus)(row.status),
+            triggeredAt: row.triggered_at,
+            startedAt: row.started_at || undefined,
+            finishedAt: row.finished_at || undefined,
+            error: row.error || undefined,
+            eventSnapshot: row.event_snapshot_json ? parseJson(row.event_snapshot_json, {}) : undefined,
+            threadId: row.thread_id || undefined,
+            runId: row.run_id || undefined,
+            deliveryMode: row.delivery_mode || undefined,
+            deliveryStatus: row.delivery_status || undefined,
+            deliveryError: row.delivery_error || undefined,
+            lastBridgeEventAt: row.last_bridge_event_at || undefined,
+        };
+    }
+    createMonitorId() {
+        let id = `monitor:${(0, node_crypto_1.randomUUID)()}`;
+        for (let attempt = 0; attempt < 5 && this.get(id); attempt += 1) {
+            id = `monitor:${(0, node_crypto_1.randomUUID)()}`;
+        }
+        if (this.get(id))
+            throw new Error('Unable to allocate a unique automation monitor id.');
+        return id;
+    }
+}
+exports.LocalAutomationMonitorStore = LocalAutomationMonitorStore;
+function parseJson(value, fallback) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return fallback;
+    }
+}

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; } });