@loicngr/kobo 0.1.1

package/dist/server/services/pr-template-service.js

@@ -0,0 +1,38 @@
+import path from 'node:path';
+function formatTaskLine(t) {
+    const mark = t.status === 'done' ? 'x' : ' ';
+    return `- [${mark}] ${t.title}`;
+}
+function buildVariableMap(ctx) {
+    const regularTasks = ctx.tasks.filter((t) => !t.isAcceptanceCriterion);
+    const criteria = ctx.tasks.filter((t) => t.isAcceptanceCriterion);
+    return {
+        pr_number: String(ctx.prNumber),
+        pr_url: ctx.prUrl,
+        branch_name: ctx.workspace.workingBranch,
+        source_branch: ctx.workspace.sourceBranch,
+        workspace_name: ctx.workspace.name,
+        project_name: path.basename(ctx.workspace.projectPath),
+        notion_url: ctx.workspace.notionUrl ?? '',
+        commits: ctx.commits,
+        diff_stats: ctx.diffStats,
+        tasks: regularTasks.map(formatTaskLine).join('\n'),
+        acceptance_criteria: criteria.map(formatTaskLine).join('\n'),
+    };
+}
+/**
+ * Render a PR prompt template by substituting {{variable}} placeholders.
+ *
+ * Known variables are substituted from the context. Unknown variables are
+ * left intact (useful for user-defined placeholders the agent may resolve
+ * itself). The function is pure: no I/O, no side effects.
+ */
+export function renderPrTemplate(template, ctx) {
+    const vars = buildVariableMap(ctx);
+    return template.replace(/\{\{(\w+)\}\}/g, (match, name) => {
+        if (Object.hasOwn(vars, name)) {
+            return vars[name];
+        }
+        return match; // leave unknown variables as-is
+    });
+}

package/dist/server/services/settings-service.js

@@ -0,0 +1,205 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getSettingsPath } from '../utils/paths.js';
+const DEFAULT_GIT_CONVENTIONS = `# Git conventions
+
+## Commits
+- Use Conventional Commits: \`type(scope): subject\`
+- Types: feat, fix, docs, style, refactor, test, chore, perf, build, ci
+- Subject: imperative mood, lowercase, no trailing period, max 72 chars
+- Body: wrap at 72 chars, explain *why* not *what*
+- Reference issues with \`Refs #123\` or \`Closes #123\`
+
+## Branches
+- Feature: \`feature/<short-kebab-case>\`
+- Fix: \`fix/<short-kebab-case>\`
+- Never commit directly to main/master/develop
+
+## Workflow
+- Rebase on the source branch before opening a PR, do not merge it in
+- Keep commits atomic and self-contained (each compiles and passes tests)
+- Squash fixup commits before pushing
+- Never force-push to shared branches
+
+## Safety
+- Never run destructive commands (reset --hard, push --force, clean -fd) without explicit user confirmation
+- Never skip hooks (--no-verify) unless the user explicitly asks
+- Always inspect \`git status\` and \`git diff\` before staging
+`;
+const DEFAULT_PR_PROMPT_TEMPLATE = `A pull request has been opened: {{pr_url}} (#{{pr_number}})
+
+Context:
+- Workspace: {{workspace_name}}
+- Project: {{project_name}}
+- Branch: \`{{branch_name}}\` → \`{{source_branch}}\`
+- Notion: {{notion_url}}
+
+Changes:
+{{diff_stats}}
+
+Commits:
+{{commits}}
+
+Tasks:
+{{tasks}}
+
+Acceptance criteria:
+{{acceptance_criteria}}
+
+Please:
+1. Review the PR description on GitHub and improve it if needed (add a proper summary, screenshots if relevant, a test plan)
+2. Verify that all acceptance criteria are checked
+3. Post a comment on the PR summarizing what was done and any follow-up items
+`;
+let settingsFilePath = getSettingsPath();
+/** Override the settings file path (used by tests). */
+export function _setSettingsPath(p) {
+    settingsFilePath = p;
+}
+function defaultSettings() {
+    return {
+        global: {
+            defaultModel: 'auto',
+            prPromptTemplate: DEFAULT_PR_PROMPT_TEMPLATE,
+            gitConventions: DEFAULT_GIT_CONVENTIONS,
+        },
+        projects: [],
+    };
+}
+function defaultProjectSettings(projectPath) {
+    return {
+        path: projectPath,
+        displayName: '',
+        defaultSourceBranch: '',
+        defaultModel: '',
+        prPromptTemplate: '',
+        gitConventions: '',
+        devServer: {
+            startCommand: '',
+            stopCommand: '',
+        },
+    };
+}
+function pickKnownKeys(data, allowedKeys) {
+    return Object.fromEntries(Object.entries(data).filter(([key]) => allowedKeys.includes(key)));
+}
+function readSettings() {
+    if (!fs.existsSync(settingsFilePath)) {
+        const defaults = defaultSettings();
+        writeSettings(defaults);
+        return defaults;
+    }
+    const raw = fs.readFileSync(settingsFilePath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed.global !== 'object' || !Array.isArray(parsed.projects)) {
+        const defaults = defaultSettings();
+        writeSettings(defaults);
+        return defaults;
+    }
+    // Backfill missing fields on load (forward compat for old settings.json)
+    if (typeof parsed.global.gitConventions !== 'string') {
+        parsed.global.gitConventions = '';
+    }
+    for (const p of parsed.projects) {
+        if (typeof p.gitConventions !== 'string')
+            p.gitConventions = '';
+    }
+    return parsed;
+}
+function writeSettings(settings) {
+    const tmpPath = `${settingsFilePath}.tmp`;
+    const dir = path.dirname(settingsFilePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(tmpPath, JSON.stringify(settings, null, 2), 'utf-8');
+    fs.renameSync(tmpPath, settingsFilePath);
+}
+export function getSettings() {
+    return readSettings();
+}
+export function getGlobalSettings() {
+    return readSettings().global;
+}
+export function getProjectSettings(projectPath) {
+    const settings = readSettings();
+    return settings.projects.find((p) => p.path === projectPath) ?? null;
+}
+export function getEffectiveSettings(projectPath) {
+    const settings = readSettings();
+    const project = settings.projects.find((p) => p.path === projectPath) ?? null;
+    if (!project) {
+        return {
+            model: settings.global.defaultModel,
+            prPromptTemplate: settings.global.prPromptTemplate,
+            gitConventions: settings.global.gitConventions,
+            sourceBranch: '',
+            devServer: null,
+        };
+    }
+    return {
+        model: project.defaultModel || settings.global.defaultModel,
+        prPromptTemplate: project.prPromptTemplate || settings.global.prPromptTemplate,
+        gitConventions: project.gitConventions || settings.global.gitConventions,
+        sourceBranch: project.defaultSourceBranch,
+        devServer: project.devServer,
+    };
+}
+export function updateGlobalSettings(data) {
+    const settings = readSettings();
+    const allowedGlobalKeys = ['defaultModel', 'prPromptTemplate', 'gitConventions'];
+    const filtered = pickKnownKeys(data, allowedGlobalKeys);
+    settings.global = { ...settings.global, ...filtered };
+    writeSettings(settings);
+    return settings.global;
+}
+export function upsertProject(projectPath, data) {
+    const allowedProjectKeys = [
+        'displayName',
+        'defaultSourceBranch',
+        'defaultModel',
+        'prPromptTemplate',
+        'gitConventions',
+        'devServer',
+    ];
+    const allowedDevServerKeys = ['startCommand', 'stopCommand'];
+    const filtered = pickKnownKeys(data, allowedProjectKeys);
+    if (filtered.devServer) {
+        filtered.devServer = pickKnownKeys(filtered.devServer, allowedDevServerKeys);
+    }
+    const settings = readSettings();
+    const idx = settings.projects.findIndex((p) => p.path === projectPath);
+    if (idx >= 0) {
+        // Update existing project — merge devServer separately to allow partial updates
+        const existing = settings.projects[idx];
+        const updatedDevServer = filtered.devServer ? { ...existing.devServer, ...filtered.devServer } : existing.devServer;
+        settings.projects[idx] = {
+            ...existing,
+            ...filtered,
+            path: projectPath,
+            devServer: updatedDevServer,
+        };
+    }
+    else {
+        // Add new project
+        const newProject = {
+            ...defaultProjectSettings(projectPath),
+            ...filtered,
+            path: projectPath,
+        };
+        if (filtered.devServer) {
+            newProject.devServer = { ...defaultProjectSettings(projectPath).devServer, ...filtered.devServer };
+        }
+        settings.projects.push(newProject);
+    }
+    writeSettings(settings);
+    return settings.projects.find((p) => p.path === projectPath);
+}
+export function deleteProject(projectPath) {
+    const settings = readSettings();
+    settings.projects = settings.projects.filter((p) => p.path !== projectPath);
+    writeSettings(settings);
+}
+export function listProjects() {
+    return readSettings().projects;
+}

package/dist/server/services/websocket-service.js

@@ -0,0 +1,212 @@
+import { nanoid } from 'nanoid';
+import { getDb } from '../db/index.js';
+// ── State ──────────────────────────────────────────────────────────────────────
+/** Maps each WS client to the set of workspaceIds they are subscribed to */
+const clients = new Map();
+let messageHandler = null;
+export function setMessageHandler(handler) {
+    messageHandler = handler;
+}
+// ── Connection handling ────────────────────────────────────────────────────────
+export function handleConnection(ws) {
+    // Register client with empty subscription set
+    clients.set(ws, new Set());
+    ws.on('message', (data) => {
+        let msg;
+        try {
+            msg = JSON.parse(data.toString());
+        }
+        catch {
+            ws.send(JSON.stringify({ type: 'error', payload: { message: 'Invalid JSON' } }));
+            return;
+        }
+        const { type, payload } = msg;
+        switch (type) {
+            case 'subscribe': {
+                const workspaceId = payload?.workspaceId;
+                if (!workspaceId) {
+                    ws.send(JSON.stringify({ type: 'error', payload: { message: 'Missing workspaceId' } }));
+                    return;
+                }
+                const subs = clients.get(ws);
+                subs?.add(workspaceId);
+                ws.send(JSON.stringify({ type: 'subscribed', payload: { workspaceId } }));
+                break;
+            }
+            case 'unsubscribe': {
+                const workspaceId = payload?.workspaceId;
+                if (!workspaceId) {
+                    ws.send(JSON.stringify({ type: 'error', payload: { message: 'Missing workspaceId' } }));
+                    return;
+                }
+                const subs = clients.get(ws);
+                subs?.delete(workspaceId);
+                ws.send(JSON.stringify({ type: 'unsubscribed', payload: { workspaceId } }));
+                break;
+            }
+            case 'sync:request': {
+                const p = payload;
+                const lastEventId = p?.lastEventId ?? '';
+                // I2: Accept optional workspaceIds so the client can sync even before re-subscribing
+                const workspaceIds = p?.workspaceIds;
+                handleSyncRequest(ws, lastEventId, workspaceIds);
+                break;
+            }
+            // Routed messages — delegated to agent-manager via messageHandler
+            case 'chat:message':
+            case 'workspace:start':
+            case 'workspace:stop':
+            case 'devserver:start':
+            case 'devserver:stop': {
+                if (messageHandler) {
+                    messageHandler(type, payload);
+                }
+                break;
+            }
+            default:
+                ws.send(JSON.stringify({ type: 'error', payload: { message: `Unknown message type: ${type}` } }));
+        }
+    });
+    ws.on('close', () => {
+        clients.delete(ws);
+    });
+    ws.on('error', () => {
+        clients.delete(ws);
+    });
+}
+// ── Broadcasting ───────────────────────────────────────────────────────────────
+/**
+ * Broadcast an event to all clients subscribed to the given workspace.
+ * Persists the event to the ws_events table.
+ * Returns the event id.
+ */
+export function emit(workspaceId, type, payload, sessionId) {
+    const id = nanoid();
+    const createdAt = new Date().toISOString();
+    // C3: Persist to DB — best-effort only; don't let FK violation (deleted workspace) break the broadcast
+    try {
+        const db = getDb();
+        db.prepare('INSERT INTO ws_events (id, workspace_id, type, payload, session_id, created_at) VALUES (?, ?, ?, ?, ?, ?)').run(id, workspaceId, type, JSON.stringify(payload), sessionId ?? null, createdAt);
+    }
+    catch (err) {
+        console.error(`[websocket-service] Failed to persist event (workspace=${workspaceId}, type=${type}):`, err);
+    }
+    // Build the event object to send
+    const event = { id, workspaceId, type, payload, sessionId, createdAt };
+    const message = JSON.stringify(event);
+    // Broadcast to subscribed clients
+    for (const [ws, subs] of clients) {
+        if (subs.has(workspaceId) && ws.readyState === 1 /* WebSocket.OPEN */) {
+            ws.send(message);
+        }
+    }
+    return id;
+}
+/**
+ * Broadcast an event to subscribed clients WITHOUT persisting to the database.
+ * Used for ephemeral status updates (e.g., dev-server status) that don't need replay.
+ */
+export function emitEphemeral(workspaceId, type, payload) {
+    const id = nanoid();
+    const createdAt = new Date().toISOString();
+    const event = { id, workspaceId, type, payload, createdAt };
+    const message = JSON.stringify(event);
+    for (const [ws, subs] of clients) {
+        if (subs.has(workspaceId) && ws.readyState === 1 /* WebSocket.OPEN */) {
+            ws.send(message);
+        }
+    }
+}
+// ── Sync (replay missed events) ────────────────────────────────────────────────
+/**
+ * Sends all events after lastEventId for workspaces the client is subscribed to.
+ * I2: If workspaceIds is provided, use those instead of the client's current subscriptions
+ * so the client can sync even before re-subscribing (e.g. after a reconnect).
+ */
+export function handleSyncRequest(ws, lastEventId, workspaceIds) {
+    // I2: Use provided workspaceIds first, fall back to current subscriptions
+    const resolvedIds = workspaceIds && workspaceIds.length > 0
+        ? workspaceIds
+        : (() => {
+            const subs = clients.get(ws);
+            return subs ? [...subs] : [];
+        })();
+    if (resolvedIds.length === 0) {
+        ws.send(JSON.stringify({ type: 'sync:empty', payload: { message: 'No subscriptions' } }));
+        return;
+    }
+    const db = getDb();
+    // Build a query with placeholders for all subscribed workspaces
+    const placeholders = resolvedIds.map(() => '?').join(', ');
+    let rows;
+    if (lastEventId) {
+        // Get the rowid of the last event to compare ordering
+        const lastRow = db.prepare('SELECT rowid FROM ws_events WHERE id = ?').get(lastEventId);
+        if (lastRow) {
+            rows = db
+                .prepare(`SELECT * FROM ws_events WHERE workspace_id IN (${placeholders}) AND rowid > ? ORDER BY rowid ASC`)
+                .all(...resolvedIds, lastRow.rowid);
+        }
+        else {
+            // lastEventId not found — send all events for subscribed workspaces
+            rows = db
+                .prepare(`SELECT * FROM ws_events WHERE workspace_id IN (${placeholders}) ORDER BY rowid ASC`)
+                .all(...resolvedIds);
+        }
+    }
+    else {
+        // No lastEventId — send all events
+        rows = db
+            .prepare(`SELECT * FROM ws_events WHERE workspace_id IN (${placeholders}) ORDER BY rowid ASC`)
+            .all(...resolvedIds);
+    }
+    const events = rows.map((row) => {
+        let parsedPayload;
+        try {
+            parsedPayload = JSON.parse(row.payload);
+        }
+        catch {
+            parsedPayload = { raw: row.payload };
+        }
+        return {
+            id: row.id,
+            workspaceId: row.workspace_id,
+            type: row.type,
+            payload: parsedPayload,
+            sessionId: row.session_id ?? undefined,
+            createdAt: row.created_at,
+        };
+    });
+    ws.send(JSON.stringify({ type: 'sync:response', payload: { events } }));
+}
+// ── Cleanup ────────────────────────────────────────────────────────────────────
+/**
+ * Delete old events keeping only the last N (default 1000) per workspace.
+ */
+export function cleanupOldEvents(workspaceId, keepCount = 1000) {
+    const db = getDb();
+    db.prepare(`
+    DELETE FROM ws_events
+    WHERE workspace_id = ?
+      AND rowid NOT IN (
+        SELECT rowid FROM ws_events
+        WHERE workspace_id = ?
+        ORDER BY rowid DESC
+        LIMIT ?
+      )
+  `).run(workspaceId, workspaceId, keepCount);
+}
+// ── Utilities ──────────────────────────────────────────────────────────────────
+/**
+ * Return number of connected clients.
+ */
+export function getClientCount() {
+    return clients.size;
+}
+/**
+ * Get the internal clients map — exposed for testing only.
+ * @internal
+ */
+export function _getClients() {
+    return clients;
+}

package/dist/server/services/workspace-service.js

@@ -0,0 +1,208 @@
+import { nanoid } from 'nanoid';
+import { getDb } from '../db/index.js';
+// Valid status transitions
+const VALID_TRANSITIONS = {
+    created: ['extracting', 'brainstorming', 'idle', 'error'],
+    extracting: ['brainstorming', 'idle', 'error'],
+    brainstorming: ['executing', 'completed', 'idle', 'error'],
+    executing: ['completed', 'idle', 'error', 'quota'],
+    completed: ['idle', 'executing'],
+    idle: ['executing', 'brainstorming', 'extracting', 'error'],
+    error: ['idle', 'executing', 'brainstorming', 'extracting'],
+    quota: ['idle', 'executing'],
+};
+function mapWorkspace(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        projectPath: row.project_path,
+        sourceBranch: row.source_branch,
+        workingBranch: row.working_branch,
+        status: row.status,
+        notionUrl: row.notion_url,
+        notionPageId: row.notion_page_id,
+        model: row.model,
+        devServerStatus: row.dev_server_status,
+        archivedAt: row.archived_at,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function mapTask(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspace_id,
+        title: row.title,
+        status: row.status,
+        isAcceptanceCriterion: row.is_acceptance_criterion === 1,
+        sortOrder: row.sort_order,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export function createWorkspace(data) {
+    const db = getDb();
+    const now = new Date().toISOString();
+    const id = nanoid();
+    db.prepare(`
+    INSERT INTO workspaces (id, name, project_path, source_branch, working_branch, status, notion_url, notion_page_id, model, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, 'created', ?, ?, ?, ?, ?)
+  `).run(id, data.name, data.projectPath, data.sourceBranch, data.workingBranch, data.notionUrl ?? null, data.notionPageId ?? null, data.model ?? 'claude-opus-4-6', now, now);
+    return getWorkspace(id);
+}
+export function getWorkspace(id) {
+    const db = getDb();
+    const row = db.prepare('SELECT * FROM workspaces WHERE id = ?').get(id);
+    return row ? mapWorkspace(row) : null;
+}
+export function listWorkspaces(includeArchived = false) {
+    const db = getDb();
+    const sql = includeArchived
+        ? 'SELECT * FROM workspaces ORDER BY updated_at DESC'
+        : 'SELECT * FROM workspaces WHERE archived_at IS NULL ORDER BY updated_at DESC';
+    const rows = db.prepare(sql).all();
+    return rows.map(mapWorkspace);
+}
+export function listArchivedWorkspaces() {
+    const db = getDb();
+    const rows = db
+        .prepare('SELECT * FROM workspaces WHERE archived_at IS NOT NULL ORDER BY archived_at DESC')
+        .all();
+    return rows.map(mapWorkspace);
+}
+export function updateWorkspaceStatus(id, status) {
+    const db = getDb();
+    const workspace = getWorkspace(id);
+    if (!workspace) {
+        throw new Error(`Workspace '${id}' not found`);
+    }
+    const allowedTransitions = VALID_TRANSITIONS[workspace.status];
+    if (!allowedTransitions.includes(status)) {
+        throw new Error(`Invalid status transition from '${workspace.status}' to '${status}'. Allowed: ${allowedTransitions.join(', ')}`);
+    }
+    const now = new Date().toISOString();
+    db.prepare('UPDATE workspaces SET status = ?, updated_at = ? WHERE id = ?').run(status, now, id);
+    return getWorkspace(id);
+}
+export function updateWorkspaceName(id, name) {
+    const db = getDb();
+    const now = new Date().toISOString();
+    db.prepare('UPDATE workspaces SET name = ?, updated_at = ? WHERE id = ?').run(name, now, id);
+    return getWorkspace(id);
+}
+export function updateDevServerStatus(id, status) {
+    const db = getDb();
+    db.prepare('UPDATE workspaces SET dev_server_status = ? WHERE id = ?').run(status, id);
+}
+export function deleteWorkspace(id) {
+    const db = getDb();
+    db.prepare('DELETE FROM workspaces WHERE id = ?').run(id);
+}
+export function createTask(workspaceId, data) {
+    const db = getDb();
+    // I2: explicit workspace existence check before INSERT
+    const exists = db.prepare('SELECT 1 FROM workspaces WHERE id = ?').get(workspaceId);
+    if (!exists) {
+        throw new Error(`Workspace not found: '${workspaceId}'`);
+    }
+    const now = new Date().toISOString();
+    const id = nanoid();
+    db.prepare(`
+    INSERT INTO tasks (id, workspace_id, title, status, is_acceptance_criterion, sort_order, created_at, updated_at)
+    VALUES (?, ?, ?, 'pending', ?, ?, ?, ?)
+  `).run(id, workspaceId, data.title, data.isAcceptanceCriterion ? 1 : 0, data.sortOrder ?? 0, now, now);
+    const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(id);
+    return mapTask(row);
+}
+export function listTasks(workspaceId) {
+    const db = getDb();
+    const rows = db
+        .prepare('SELECT * FROM tasks WHERE workspace_id = ? ORDER BY sort_order ASC')
+        .all(workspaceId);
+    return rows.map(mapTask);
+}
+export function updateTaskStatus(taskId, status) {
+    const db = getDb();
+    const now = new Date().toISOString();
+    db.prepare('UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?').run(status, now, taskId);
+    const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(taskId);
+    if (!row) {
+        throw new Error(`Task '${taskId}' not found`);
+    }
+    return mapTask(row);
+}
+export function updateTaskTitle(taskId, title) {
+    if (!title?.trim()) {
+        throw new Error('Task title cannot be empty');
+    }
+    const db = getDb();
+    const now = new Date().toISOString();
+    const result = db.prepare('UPDATE tasks SET title = ?, updated_at = ? WHERE id = ?').run(title.trim(), now, taskId);
+    if (result.changes === 0) {
+        throw new Error(`Task '${taskId}' not found`);
+    }
+    const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(taskId);
+    return mapTask(row);
+}
+export function deleteTask(taskId) {
+    const db = getDb();
+    db.prepare('DELETE FROM tasks WHERE id = ?').run(taskId);
+}
+export function getWorkspaceWithTasks(id) {
+    const workspace = getWorkspace(id);
+    if (!workspace)
+        return null;
+    const tasks = listTasks(id);
+    return { ...workspace, tasks };
+}
+export function archiveWorkspace(id) {
+    const db = getDb();
+    const workspace = getWorkspace(id);
+    if (!workspace) {
+        throw new Error(`Workspace '${id}' not found`);
+    }
+    if (workspace.archivedAt) {
+        throw new Error(`Workspace '${id}' is already archived`);
+    }
+    const now = new Date().toISOString();
+    db.prepare('UPDATE workspaces SET archived_at = ?, updated_at = ? WHERE id = ?').run(now, now, id);
+    return getWorkspace(id);
+}
+export function unarchiveWorkspace(id) {
+    const db = getDb();
+    const workspace = getWorkspace(id);
+    if (!workspace) {
+        throw new Error(`Workspace '${id}' not found`);
+    }
+    if (!workspace.archivedAt) {
+        throw new Error(`Workspace '${id}' is not archived`);
+    }
+    const now = new Date().toISOString();
+    db.prepare('UPDATE workspaces SET archived_at = NULL, updated_at = ? WHERE id = ?').run(now, id);
+    return getWorkspace(id);
+}
+function mapSession(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspace_id,
+        pid: row.pid,
+        claudeSessionId: row.claude_session_id,
+        status: row.status,
+        startedAt: row.started_at,
+        endedAt: row.ended_at,
+    };
+}
+export function listSessions(workspaceId) {
+    const db = getDb();
+    const rows = db
+        .prepare('SELECT * FROM agent_sessions WHERE workspace_id = ? ORDER BY started_at DESC')
+        .all(workspaceId);
+    return rows.map(mapSession);
+}
+export function getLatestSession(workspaceId) {
+    const db = getDb();
+    const row = db
+        .prepare('SELECT * FROM agent_sessions WHERE workspace_id = ? ORDER BY started_at DESC LIMIT 1')
+        .get(workspaceId);
+    return row ? mapSession(row) : null;
+}