@kafca/agentdock 0.1.42 → 0.1.43

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

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalSecurityStore = 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 LocalSecurityStore {
+    db;
+    updateAgentTask;
+    constructor(db, updateAgentTask) {
+        this.db = db;
+        this.updateAgentTask = updateAgentTask;
+    }
+    getWorkspaceSecuritySettings(workspaceId) {
+        const row = this.db.prepare(`
+      SELECT workspace_id, permissions_json, allow_paths_json, deny_paths_json, updated_at, updated_by
+      FROM workspace_security_settings
+      WHERE workspace_id = ?
+    `).get(workspaceId);
+        if (row) {
+            return this.toWorkspaceSecuritySettings(row);
+        }
+        const now = new Date().toISOString();
+        return {
+            workspaceId,
+            permissions: (0, utils_js_1.defaultPermissions)(),
+            allowPaths: [],
+            denyPaths: [],
+            updatedAt: now,
+        };
+    }
+    updateWorkspaceSecuritySettings(workspaceId, input) {
+        const existing = this.getWorkspaceSecuritySettings(workspaceId);
+        const now = new Date().toISOString();
+        const next = {
+            workspaceId,
+            permissions: {
+                ...existing.permissions,
+                ...(input.permissions || {}),
+            },
+            allowPaths: Array.isArray(input.allowPaths) ? input.allowPaths : existing.allowPaths,
+            denyPaths: Array.isArray(input.denyPaths) ? input.denyPaths : existing.denyPaths,
+            updatedAt: now,
+            updatedBy: input.updatedBy || existing.updatedBy,
+        };
+        this.db.prepare(`
+      INSERT INTO workspace_security_settings (workspace_id, permissions_json, allow_paths_json, deny_paths_json, updated_at, updated_by)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(workspace_id) DO UPDATE SET
+        permissions_json = excluded.permissions_json,
+        allow_paths_json = excluded.allow_paths_json,
+        deny_paths_json = excluded.deny_paths_json,
+        updated_at = excluded.updated_at,
+        updated_by = excluded.updated_by
+    `).run(workspaceId, JSON.stringify(next.permissions), JSON.stringify(next.allowPaths), JSON.stringify(next.denyPaths), now, next.updatedBy || null);
+        this.createAuditEvent({
+            type: 'permission.changed',
+            workspaceId,
+            actor: next.updatedBy || 'local',
+            summary: 'Workspace security settings changed.',
+            metadata: {
+                permissions: next.permissions,
+                allowPaths: next.allowPaths,
+                denyPaths: next.denyPaths,
+            },
+        });
+        return this.getWorkspaceSecuritySettings(workspaceId);
+    }
+    createApprovalRequest(input) {
+        const id = `approval:${(0, node_crypto_1.randomUUID)()}`;
+        const now = new Date().toISOString();
+        this.db.prepare(`
+      INSERT INTO approval_requests (
+        id, workspace_id, task_id, thread_id, run_id, device_id, kind, status, risk_level, title, description,
+        requested_action, command, scopes_json, options_json, requested_by, created_at, updated_at, expires_at, metadata_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, input.workspaceId, input.taskId || null, input.threadId || null, input.runId || null, input.deviceId || 'local', input.kind, input.riskLevel, input.title, (0, utils_js_1.redactSecrets)(input.description), (0, utils_js_1.redactSecrets)(input.requestedAction), input.command ? (0, utils_js_1.redactSecrets)(input.command) : null, JSON.stringify(input.scopes || []), JSON.stringify(input.options || []), input.requestedBy || null, now, now, input.expiresAt || null, JSON.stringify(input.metadata || {}));
+        const approval = this.getApprovalRequest(id);
+        this.createAuditEvent({
+            type: 'approval.requested',
+            workspaceId: approval.workspaceId,
+            taskId: approval.taskId,
+            approvalId: approval.approvalId,
+            actor: approval.requestedBy || 'agent',
+            summary: approval.title,
+            riskLevel: approval.riskLevel,
+            metadata: {
+                kind: approval.kind,
+                requestedAction: approval.requestedAction,
+                scopes: approval.scopes,
+            },
+        });
+        if (approval.taskId) {
+            this.updateAgentTask(approval.taskId, {
+                approvalId: approval.approvalId,
+                timelineItem: {
+                    type: 'approval_requested',
+                    title: approval.title,
+                    description: approval.description,
+                    metadata: { approvalId: approval.approvalId, riskLevel: approval.riskLevel },
+                },
+            });
+        }
+        return approval;
+    }
+    listApprovalRequests(query = {}) {
+        const predicates = [];
+        const params = [];
+        if (query.workspaceId) {
+            predicates.push('workspace_id = ?');
+            params.push(query.workspaceId);
+        }
+        if (query.taskId) {
+            predicates.push('task_id = ?');
+            params.push(query.taskId);
+        }
+        if (query.status) {
+            const statuses = (Array.isArray(query.status) ? query.status : [query.status]).map((status) => (0, index_js_1.normalizeApprovalRequestStatus)(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 approval_requests
+      ${where}
+      ORDER BY updated_at DESC
+      LIMIT ?
+    `).all(...params, limit);
+        return { approvals: rows.map((row) => this.toApprovalRequest(row)) };
+    }
+    getApprovalRequest(approvalId) {
+        const row = this.db.prepare('SELECT * FROM approval_requests WHERE id = ?').get(approvalId);
+        return row ? this.toApprovalRequest(row) : undefined;
+    }
+    resolveApprovalRequest(approvalId, input) {
+        const existing = this.getApprovalRequest(approvalId);
+        if (!existing) {
+            throw new Error(`Approval not found: ${approvalId}`);
+        }
+        const now = new Date().toISOString();
+        this.db.prepare(`
+      UPDATE approval_requests
+      SET status = ?, resolved_by = ?, resolution = ?, resolved_at = ?, updated_at = ?
+      WHERE id = ?
+    `).run(input.status, input.resolvedBy || existing.resolvedBy || 'local', input.resolution || existing.resolution || null, now, now, approvalId);
+        const approval = this.getApprovalRequest(approvalId);
+        this.createAuditEvent({
+            type: input.status === 'rejected' ? 'approval.rejected' : 'approval.resolved',
+            workspaceId: approval.workspaceId,
+            taskId: approval.taskId,
+            approvalId: approval.approvalId,
+            actor: approval.resolvedBy || 'local',
+            summary: `Approval ${input.status}: ${approval.title}`,
+            riskLevel: approval.riskLevel,
+            metadata: { resolution: approval.resolution },
+        });
+        if (approval.taskId) {
+            this.updateAgentTask(approval.taskId, {
+                timelineItem: {
+                    type: 'approval_resolved',
+                    title: `Approval ${input.status}`,
+                    description: approval.resolution || approval.title,
+                    metadata: { approvalId: approval.approvalId, status: input.status },
+                },
+            });
+        }
+        return approval;
+    }
+    createAuditEvent(input) {
+        const id = `audit:${(0, node_crypto_1.randomUUID)()}`;
+        const now = new Date().toISOString();
+        this.db.prepare(`
+      INSERT INTO audit_events (id, type, workspace_id, task_id, approval_id, actor, summary, risk_level, created_at, metadata_json)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, input.type, input.workspaceId || null, input.taskId || null, input.approvalId || null, input.actor || null, (0, utils_js_1.redactSecrets)(input.summary), input.riskLevel || null, now, JSON.stringify(input.metadata || {}));
+        return this.toAuditEvent(this.db.prepare('SELECT * FROM audit_events WHERE id = ?').get(id));
+    }
+    listAuditEvents(query = {}) {
+        const predicates = [];
+        const params = [];
+        if (query.workspaceId) {
+            predicates.push('workspace_id = ?');
+            params.push(query.workspaceId);
+        }
+        if (query.taskId) {
+            predicates.push('task_id = ?');
+            params.push(query.taskId);
+        }
+        if (query.approvalId) {
+            predicates.push('approval_id = ?');
+            params.push(query.approvalId);
+        }
+        if (query.type) {
+            const types = Array.isArray(query.type) ? query.type : [query.type];
+            predicates.push(`type IN (${types.map(() => '?').join(', ')})`);
+            params.push(...types);
+        }
+        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 audit_events
+      ${where}
+      ORDER BY created_at DESC
+      LIMIT ?
+    `).all(...params, limit);
+        return { events: rows.map((row) => this.toAuditEvent(row)) };
+    }
+    toWorkspaceSecuritySettings(row) {
+        return {
+            workspaceId: row.workspace_id,
+            permissions: {
+                ...(0, utils_js_1.defaultPermissions)(),
+                ...(0, utils_js_1.parseJson)(row.permissions_json, {}),
+            },
+            allowPaths: (0, utils_js_1.parseJson)(row.allow_paths_json, []),
+            denyPaths: (0, utils_js_1.parseJson)(row.deny_paths_json, []),
+            updatedAt: row.updated_at,
+            updatedBy: row.updated_by || undefined,
+        };
+    }
+    toApprovalRequest(row) {
+        return {
+            approvalId: row.id,
+            workspaceId: row.workspace_id,
+            taskId: row.task_id || undefined,
+            threadId: row.thread_id || undefined,
+            runId: row.run_id || undefined,
+            deviceId: row.device_id,
+            kind: row.kind,
+            status: (0, index_js_1.normalizeApprovalRequestStatus)(row.status),
+            riskLevel: row.risk_level,
+            title: row.title,
+            description: row.description,
+            requestedAction: row.requested_action,
+            command: row.command || undefined,
+            scopes: (0, utils_js_1.parseJson)(row.scopes_json, []),
+            options: (0, utils_js_1.parseJson)(row.options_json, []),
+            requestedBy: row.requested_by || undefined,
+            resolvedBy: row.resolved_by || undefined,
+            resolution: row.resolution || undefined,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            resolvedAt: row.resolved_at || undefined,
+            expiresAt: row.expires_at || undefined,
+            metadata: (0, utils_js_1.parseJson)(row.metadata_json, {}),
+        };
+    }
+    toAuditEvent(row) {
+        return {
+            auditId: row.id,
+            type: row.type,
+            workspaceId: row.workspace_id || undefined,
+            taskId: row.task_id || undefined,
+            approvalId: row.approval_id || undefined,
+            actor: row.actor || undefined,
+            summary: row.summary,
+            riskLevel: row.risk_level || undefined,
+            createdAt: row.created_at,
+            metadata: (0, utils_js_1.parseJson)(row.metadata_json, {}),
+        };
+    }
+}
+exports.LocalSecurityStore = LocalSecurityStore;

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;