@bbigbang/core 0.1.0

package/dist/services/workspaceSessionService.js

@@ -0,0 +1,245 @@
+import { randomUUID } from 'node:crypto';
+import { getRuntimeDriver } from '@bbigbang/protocol';
+import { createSession } from '@bbigbang/runtime-acp';
+export class WorkspaceSessionServiceError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+export class WorkspaceSessionService {
+    db;
+    workbenchRootService;
+    getAgentById;
+    constructor(params) {
+        this.db = params.db;
+        this.workbenchRootService = params.workbenchRootService;
+        this.getAgentById = params.getAgentById;
+    }
+    ensureSession(params) {
+        const agentId = normalizeRequiredText(params.agentId, 'agentId is required.');
+        const workspaceRootId = normalizeRequiredText(params.workspaceRootId, 'workspaceRootId is required.');
+        const agent = this.getAgentById(agentId);
+        if (!agent)
+            throw new WorkspaceSessionServiceError(404, 'Agent not found.');
+        if (!params.canAccessAgent(agentId)) {
+            throw new WorkspaceSessionServiceError(403, 'Access denied.');
+        }
+        const root = this.resolveExecutableRoot(workspaceRootId, agentId);
+        const title = normalizeOptionalText(params.title);
+        const existing = this.selectLatestOpenSession(params.user.id, agentId, workspaceRootId);
+        if (existing) {
+            const now = Date.now();
+            this.db.prepare(`UPDATE workspace_sessions
+            SET title = CASE WHEN ? IS NULL THEN title ELSE ? END,
+                last_active_at = ?,
+                updated_at = ?
+          WHERE workspace_session_id = ?`).run(title, title, now, now, existing.workspaceSessionId);
+            return {
+                session: this.getSessionForUser(existing.workspaceSessionId, params.user, params.canAccessAgent),
+                created: false,
+            };
+        }
+        const now = Date.now();
+        const sessionKey = randomUUID();
+        const runtime = getRuntimeDriver(agent.agentType);
+        createSession(this.db, {
+            sessionKey,
+            agentCommand: runtime.command,
+            agentArgs: runtime.args,
+            cwd: root.rootPath,
+            loadSupported: false,
+        });
+        const workspaceSessionId = randomUUID();
+        this.db.prepare(`INSERT INTO workspace_sessions(
+         workspace_session_id, agent_id, project_id, workspace_root_id, title, status,
+         runtime_profile, session_key, created_by_user_id, created_at, updated_at,
+         last_active_at, archived_at
+       )
+       VALUES(?, ?, ?, ?, ?, 'idle', 'workspace_native', ?, ?, ?, ?, ?, NULL)`).run(workspaceSessionId, agentId, root.kind === 'project_space' ? root.projectId ?? null : null, workspaceRootId, title ?? '', sessionKey, params.user.id, now, now, now);
+        return {
+            session: this.getSessionForUser(workspaceSessionId, params.user, params.canAccessAgent),
+            created: true,
+        };
+    }
+    listSessions(params) {
+        const agentId = normalizeOptionalText(params.agentId);
+        const workspaceRootId = normalizeOptionalText(params.workspaceRootId);
+        if (agentId && !params.canAccessAgent(agentId)) {
+            throw new WorkspaceSessionServiceError(403, 'Access denied.');
+        }
+        const conditions = [];
+        const values = [];
+        if (!params.user.isAdmin) {
+            conditions.push('created_by_user_id = ?');
+            values.push(params.user.id);
+        }
+        if (agentId) {
+            conditions.push('agent_id = ?');
+            values.push(agentId);
+        }
+        if (workspaceRootId) {
+            conditions.push('workspace_root_id = ?');
+            values.push(workspaceRootId);
+        }
+        if (!params.includeArchived) {
+            conditions.push('archived_at IS NULL');
+        }
+        const rows = this.db.prepare(`${WORKSPACE_SESSION_SELECT}
+       ${conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : ''}
+       ORDER BY last_active_at DESC, updated_at DESC`).all(...values);
+        return {
+            sessions: rows
+                .filter((row) => this.canReadSessionRow(row, params.user, params.canAccessAgent))
+                .map(mapWorkspaceSessionRow),
+        };
+    }
+    getSessionForUser(workspaceSessionId, user, canAccessAgent) {
+        const row = this.selectSession(workspaceSessionId);
+        if (!row)
+            throw new WorkspaceSessionServiceError(404, 'Workspace session not found.');
+        this.assertSessionAccess(row, user, canAccessAgent);
+        return mapWorkspaceSessionRow(row);
+    }
+    getRuntimeContext(params) {
+        const row = this.selectSession(params.workspaceSessionId);
+        if (!row)
+            throw new WorkspaceSessionServiceError(404, 'Workspace session not found.');
+        const root = this.assertSessionAccess(row, params.user, params.canAccessAgent);
+        const agent = this.getAgentById(row.agentId);
+        if (!agent)
+            throw new WorkspaceSessionServiceError(404, 'Agent not found.');
+        return {
+            session: mapWorkspaceSessionRow(row),
+            sessionKey: row.sessionKey,
+            agent,
+            root,
+        };
+    }
+    archiveSession(params) {
+        const row = this.selectSession(params.workspaceSessionId);
+        if (!row)
+            throw new WorkspaceSessionServiceError(404, 'Workspace session not found.');
+        this.assertSessionAccess(row, params.user, params.canAccessAgent);
+        if (row.status !== 'idle' && row.status !== 'failed') {
+            throw new WorkspaceSessionServiceError(409, 'Only idle or failed workspace sessions can be archived.');
+        }
+        if (row.archivedAt != null)
+            return mapWorkspaceSessionRow(row);
+        const now = Date.now();
+        this.db.prepare(`UPDATE workspace_sessions
+          SET archived_at = ?,
+              updated_at = ?
+        WHERE workspace_session_id = ?`).run(now, now, row.workspaceSessionId);
+        return mapWorkspaceSessionRow(this.selectSession(row.workspaceSessionId));
+    }
+    updateSessionStatus(workspaceSessionId, status, options) {
+        const now = Date.now();
+        this.db.prepare(`UPDATE workspace_sessions
+          SET status = ?,
+              updated_at = ?,
+              last_active_at = CASE WHEN ? THEN ? ELSE last_active_at END
+        WHERE workspace_session_id = ?`).run(status, now, options?.touchLastActive ? 1 : 0, now, workspaceSessionId);
+        const row = this.selectSession(workspaceSessionId);
+        return row ? mapWorkspaceSessionRow(row) : null;
+    }
+    selectLatestOpenSession(userId, agentId, workspaceRootId) {
+        return this.db.prepare(`${WORKSPACE_SESSION_SELECT}
+       WHERE created_by_user_id = ?
+         AND agent_id = ?
+         AND workspace_root_id = ?
+         AND archived_at IS NULL
+       ORDER BY last_active_at DESC, updated_at DESC
+       LIMIT 1`).get(userId, agentId, workspaceRootId) ?? null;
+    }
+    selectSession(workspaceSessionId) {
+        return this.db.prepare(`${WORKSPACE_SESSION_SELECT}
+       WHERE workspace_session_id = ?`).get(workspaceSessionId) ?? null;
+    }
+    assertSessionAccess(row, user, canAccessAgent) {
+        if (!user.isAdmin && row.createdByUserId !== user.id) {
+            throw new WorkspaceSessionServiceError(403, 'Access denied.');
+        }
+        if (!canAccessAgent(row.agentId)) {
+            throw new WorkspaceSessionServiceError(403, 'Access denied.');
+        }
+        return this.resolveExecutableRoot(row.workspaceRootId, row.agentId);
+    }
+    canReadSessionRow(row, user, canAccessAgent) {
+        if (!user.isAdmin && row.createdByUserId !== user.id)
+            return false;
+        if (!canAccessAgent(row.agentId))
+            return false;
+        try {
+            this.resolveExecutableRoot(row.workspaceRootId, row.agentId);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    resolveExecutableRoot(workspaceRootId, agentId) {
+        const root = this.workbenchRootService.getRoot(workspaceRootId);
+        if (!root)
+            throw new WorkspaceSessionServiceError(404, 'Workspace root not found.');
+        if (root.kind === 'resource_space') {
+            throw new WorkspaceSessionServiceError(409, 'Resource spaces cannot host workspace-native agent sessions.');
+        }
+        if (root.kind === 'agent_workspace' && root.agentId !== agentId) {
+            throw new WorkspaceSessionServiceError(409, 'Agent workspace root does not match the requested agent.');
+        }
+        if (root.kind === 'project_space') {
+            if (!root.projectId) {
+                throw new WorkspaceSessionServiceError(409, 'Project root is missing its project identity.');
+            }
+            if (!(root.agentIds ?? []).includes(agentId)) {
+                throw new WorkspaceSessionServiceError(409, 'Agent is not bound to this project workspace.');
+            }
+        }
+        return root;
+    }
+}
+const WORKSPACE_SESSION_SELECT = `
+  SELECT workspace_session_id as workspaceSessionId,
+         agent_id as agentId,
+         project_id as projectId,
+         workspace_root_id as workspaceRootId,
+         title,
+         status,
+         runtime_profile as runtimeProfile,
+         session_key as sessionKey,
+         created_by_user_id as createdByUserId,
+         created_at as createdAt,
+         updated_at as updatedAt,
+         last_active_at as lastActiveAt,
+         archived_at as archivedAt
+    FROM workspace_sessions`;
+function mapWorkspaceSessionRow(row) {
+    return {
+        workspaceSessionId: row.workspaceSessionId,
+        agentId: row.agentId,
+        projectId: row.projectId,
+        workspaceRootId: row.workspaceRootId,
+        title: row.title,
+        status: row.status,
+        runtimeProfile: row.runtimeProfile,
+        createdByUserId: row.createdByUserId,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+        lastActiveAt: row.lastActiveAt,
+        archivedAt: row.archivedAt,
+    };
+}
+function normalizeOptionalText(value) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    return trimmed || null;
+}
+function normalizeRequiredText(value, message) {
+    const normalized = normalizeOptionalText(value);
+    if (!normalized)
+        throw new WorkspaceSessionServiceError(400, message);
+    return normalized;
+}