@bbigbang/core 0.1.0

package/dist/services/workbenchRootService.js

@@ -0,0 +1,181 @@
+import path from 'node:path';
+export class WorkbenchRootService {
+    getAgentById;
+    getProjectById;
+    listProjects;
+    getResourceSpaceById;
+    listResourceSpaces;
+    nodeRegistry;
+    constructor(params) {
+        this.getAgentById = params.getAgentById;
+        this.getProjectById = params.getProjectById;
+        this.listProjects = params.listProjects;
+        this.getResourceSpaceById = params.getResourceSpaceById;
+        this.listResourceSpaces = params.listResourceSpaces;
+        this.nodeRegistry = params.nodeRegistry;
+    }
+    static buildAgentRootId(agentId) {
+        return `agent:${agentId}`;
+    }
+    static buildProjectRootId(projectId) {
+        return `project:${projectId}`;
+    }
+    static buildResourceRootId(resourceSpaceId) {
+        return `resource:${resourceSpaceId}`;
+    }
+    listRoots() {
+        const projectRoots = this.listProjectRoots();
+        const resourceRoots = this.listResourceSpaces()
+            .map((resourceSpace) => this.resourceSpaceToRoot(resourceSpace));
+        return [...projectRoots, ...resourceRoots];
+    }
+    getRoot(rootId) {
+        const parsed = parseWorkbenchRootId(rootId);
+        if (!parsed)
+            return null;
+        if (parsed.kind === 'agent_workspace') {
+            const agent = this.getAgentById(parsed.id);
+            const root = agent ? this.agentToMemoryRoot(agent) : null;
+            return root ? { ...root, rootPath: canonicalizeWorkbenchRootPath(agent.workspacePath) } : null;
+        }
+        if (parsed.kind === 'project_space') {
+            const project = this.getProjectById(parsed.id);
+            const root = project ? this.projectToRoot(project) : null;
+            return root ? { ...root, rootPath: canonicalizeWorkbenchRootPath(root.rootPath) } : null;
+        }
+        const resourceSpace = this.getResourceSpaceById(parsed.id);
+        const root = resourceSpace ? this.resourceSpaceToRoot(resourceSpace) : null;
+        return root ? { ...root, rootPath: canonicalizeWorkbenchRootPath(resourceSpace.rootPath) } : null;
+    }
+    listProjectRoots() {
+        return this.listProjects()
+            .map((project) => this.projectToRoot(project))
+            .filter((root) => !!root);
+    }
+    agentToMemoryRoot(agent) {
+        if (!agent.workspacePath)
+            return null;
+        const node = agent.nodeId ? this.nodeRegistry.getNode(agent.nodeId) : null;
+        const terminalSupported = Boolean(agent.nodeId && node?.terminalBackendAvailable);
+        return {
+            workbenchRootId: WorkbenchRootService.buildAgentRootId(agent.agentId),
+            kind: 'agent_workspace',
+            displayName: agent.name,
+            rootPath: canonicalizeWorkbenchRootPath(agent.workspacePath),
+            nodeId: agent.nodeId ?? null,
+            agentId: agent.agentId,
+            writable: true,
+            terminalSupported,
+            terminalDisabledReason: agent.nodeId
+                ? terminalSupported
+                    ? null
+                    : 'Persistent terminal backend is unavailable on the assigned node.'
+                : 'Agent is not assigned to a remote node.',
+            sourceLabel: 'Agent Workspace',
+        };
+    }
+    projectToRoot(project) {
+        const rootPath = project.rootPath?.trim() || null;
+        if (!rootPath || !isAbsoluteWorkbenchRootPath(rootPath))
+            return null;
+        const candidateNodeIds = project.backendType === 'local_path'
+            ? [project.nodeId].filter((value) => !!value)
+            : project.boundAgents
+                .map((agent) => agent.nodeId?.trim() || null)
+                .filter((value) => !!value);
+        const onlineNodeId = candidateNodeIds.find((nodeId) => !!this.nodeRegistry.getNode(nodeId)) ?? null;
+        const selectedNodeId = onlineNodeId ?? candidateNodeIds[0] ?? null;
+        const terminalSupported = candidateNodeIds.some((nodeId) => Boolean(this.nodeRegistry.getNode(nodeId)?.terminalBackendAvailable));
+        const agentIds = project.boundAgents.map((agent) => agent.agentId).sort((left, right) => left.localeCompare(right));
+        return {
+            workbenchRootId: WorkbenchRootService.buildProjectRootId(project.projectId),
+            kind: 'project_space',
+            displayName: project.name,
+            rootPath: canonicalizeWorkbenchRootPath(rootPath),
+            nodeId: selectedNodeId,
+            projectId: project.projectId,
+            projectBackendType: project.backendType,
+            agentIds,
+            writable: true,
+            terminalSupported,
+            terminalDisabledReason: terminalSupported
+                ? null
+                : project.backendType === 'shared_mount'
+                    ? 'No bound online node currently exposes the persistent terminal backend for this shared project.'
+                    : 'Persistent terminal backend is unavailable on the bound node.',
+            sourceLabel: project.backendType === 'shared_mount' ? 'Shared Project' : 'Project',
+        };
+    }
+    resourceSpaceToRoot(resourceSpace) {
+        const node = resourceSpace.nodeId ? this.nodeRegistry.getNode(resourceSpace.nodeId) : null;
+        const terminalSupported = resourceSpace.backendType === 'node_path'
+            && !!resourceSpace.nodeId
+            && Boolean(node?.terminalBackendAvailable);
+        const terminalDisabledReason = terminalSupported
+            ? null
+            : resourceSpace.backendType === 'shared_mount'
+                ? 'Shared-mount resources do not support persistent terminals.'
+                : resourceSpace.nodeId
+                    ? 'Persistent terminal backend is unavailable on the bound node.'
+                    : 'Resource space is missing its node binding.';
+        return {
+            workbenchRootId: WorkbenchRootService.buildResourceRootId(resourceSpace.resourceSpaceId),
+            kind: 'resource_space',
+            displayName: resourceSpace.name,
+            rootPath: canonicalizeWorkbenchRootPath(resourceSpace.rootPath),
+            nodeId: resourceSpace.nodeId ?? null,
+            resourceSpaceId: resourceSpace.resourceSpaceId,
+            resourceType: resourceSpace.resourceType,
+            backendType: resourceSpace.backendType,
+            writable: false,
+            terminalSupported,
+            terminalDisabledReason,
+            sourceLabel: 'Shared Resource',
+        };
+    }
+}
+function parseWorkbenchRootId(rootId) {
+    if (rootId.startsWith('agent:')) {
+        const id = rootId.slice('agent:'.length).trim();
+        return id ? { kind: 'agent_workspace', id } : null;
+    }
+    if (rootId.startsWith('project:')) {
+        const id = rootId.slice('project:'.length).trim();
+        return id ? { kind: 'project_space', id } : null;
+    }
+    if (rootId.startsWith('resource:')) {
+        const id = rootId.slice('resource:'.length).trim();
+        return id ? { kind: 'resource_space', id } : null;
+    }
+    return null;
+}
+export function canonicalizeWorkbenchRootPath(rootPath) {
+    const trimmed = rootPath.trim();
+    if (!trimmed)
+        return rootPath;
+    const pathModule = detectWorkbenchPathModule(trimmed);
+    if (!pathModule.isAbsolute(trimmed))
+        return trimmed;
+    const normalized = pathModule.normalize(trimmed);
+    const parsed = pathModule.parse(normalized);
+    if (normalized === parsed.root)
+        return normalized;
+    return normalized.replace(pathModule === path.win32 ? /[\\/]+$/ : /\/+$/, '');
+}
+export function isAbsoluteWorkbenchRootPath(rootPath) {
+    const trimmed = rootPath.trim();
+    if (!trimmed)
+        return false;
+    return path.posix.isAbsolute(trimmed) || path.win32.isAbsolute(trimmed);
+}
+export function getWorkbenchPathBasename(rootPath) {
+    const canonical = canonicalizeWorkbenchRootPath(rootPath);
+    const pathModule = detectWorkbenchPathModule(canonical);
+    return pathModule.basename(canonical);
+}
+function detectWorkbenchPathModule(rootPath) {
+    if (/^[a-zA-Z]:[\\/]/.test(rootPath) || rootPath.startsWith('\\\\') || rootPath.includes('\\')) {
+        return path.win32;
+    }
+    return path.posix;
+}

package/dist/services/workbenchTerminalBroker.js

@@ -0,0 +1,378 @@
+import { randomUUID } from 'node:crypto';
+export class WorkbenchTerminalBroker {
+    pending = new Map();
+    nodeRegistry;
+    timeoutMs;
+    routesByTerminalId = new Map();
+    socketsByTerminalId = new Map();
+    terminationListeners = new Set();
+    outputListeners = new Set();
+    bufferedOutputByTerminalId = new Map();
+    constructor(params) {
+        this.nodeRegistry = params.nodeRegistry;
+        this.timeoutMs = params.timeoutMs ?? 10_000;
+    }
+    listTerminals(nodeId, workspaceRoot) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Terminal list request timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, { nodeId, kind: 'list', resolve, reject, timer });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'terminal.list.request',
+                requestId,
+                workspaceRoot,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    createTerminal(nodeId, params) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Terminal create request timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, {
+                nodeId,
+                kind: 'create',
+                bufferOutputUntilTaken: params.bufferOutputUntilTaken === true,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'terminal.create.request',
+                requestId,
+                workspaceRoot: params.workspaceRoot,
+                cwd: params.cwd,
+                name: params.name,
+                startupCommand: params.startupCommand,
+                closeOnStartupCommand: params.closeOnStartupCommand,
+                cols: params.cols,
+                rows: params.rows,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    snapshotTerminal(nodeId, terminalId) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Terminal snapshot request timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, { nodeId, kind: 'snapshot', resolve, reject, timer });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'terminal.snapshot.request',
+                requestId,
+                terminalId,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    sendInput(nodeId, terminalId, data) {
+        return this.sendNoContentRequest(nodeId, 'input', {
+            type: 'terminal.input.request',
+            requestId: randomUUID(),
+            terminalId,
+            data,
+        });
+    }
+    resizeTerminal(nodeId, terminalId, cols, rows) {
+        return this.sendNoContentRequest(nodeId, 'resize', {
+            type: 'terminal.resize.request',
+            requestId: randomUUID(),
+            terminalId,
+            cols,
+            rows,
+        });
+    }
+    closeTerminal(nodeId, terminalId) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Terminal close request timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, { nodeId, kind: 'close', terminalId, resolve, reject, timer });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'terminal.close.request',
+                requestId,
+                terminalId,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    getTerminalRoute(terminalId) {
+        return this.routesByTerminalId.get(terminalId) ?? null;
+    }
+    subscribe(terminalId, socket) {
+        let sockets = this.socketsByTerminalId.get(terminalId);
+        if (!sockets) {
+            sockets = new Set();
+            this.socketsByTerminalId.set(terminalId, sockets);
+        }
+        sockets.add(socket);
+    }
+    unsubscribe(terminalId, socket) {
+        const sockets = this.socketsByTerminalId.get(terminalId);
+        if (!sockets)
+            return;
+        sockets.delete(socket);
+        if (sockets.size === 0) {
+            this.socketsByTerminalId.delete(terminalId);
+        }
+    }
+    onTerminalTermination(listener) {
+        this.terminationListeners.add(listener);
+        return () => {
+            this.terminationListeners.delete(listener);
+        };
+    }
+    onOutput(listener) {
+        this.outputListeners.add(listener);
+        return () => {
+            this.outputListeners.delete(listener);
+        };
+    }
+    takeBufferedOutput(terminalId) {
+        const buffered = this.bufferedOutputByTerminalId.get(terminalId) ?? '';
+        this.bufferedOutputByTerminalId.delete(terminalId);
+        return buffered;
+    }
+    handleListResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'list')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.terminals) {
+            pending.reject(new Error(formatTerminalError(msg.errorCode, msg.error)));
+            return;
+        }
+        for (const terminal of msg.terminals) {
+            this.trackTerminal(terminal, pending.nodeId);
+        }
+        pending.resolve(msg.terminals);
+    }
+    handleCreateResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'create')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.terminal) {
+            pending.reject(new Error(formatTerminalError(msg.errorCode, msg.error)));
+            return;
+        }
+        this.trackTerminal(msg.terminal, pending.nodeId);
+        if (pending.bufferOutputUntilTaken) {
+            if (!this.bufferedOutputByTerminalId.has(msg.terminal.terminalId)) {
+                this.bufferedOutputByTerminalId.set(msg.terminal.terminalId, '');
+            }
+        }
+        else {
+            this.bufferedOutputByTerminalId.delete(msg.terminal.terminalId);
+        }
+        pending.resolve(msg.terminal);
+    }
+    handleSnapshotResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'snapshot')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.terminal || msg.buffer === undefined) {
+            pending.reject(new Error(formatTerminalError(msg.errorCode, msg.error)));
+            return;
+        }
+        this.trackTerminal(msg.terminal, pending.nodeId);
+        pending.resolve({
+            terminal: msg.terminal,
+            buffer: msg.buffer,
+        });
+    }
+    handleInputResponse(msg) {
+        this.handleAckResponse(msg.requestId, msg.errorCode, msg.error, 'input');
+    }
+    handleResizeResponse(msg) {
+        this.handleAckResponse(msg.requestId, msg.errorCode, msg.error, 'resize');
+    }
+    handleCloseResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'close')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error) {
+            pending.reject(new Error(formatTerminalError(msg.errorCode, msg.error)));
+            return;
+        }
+        this.disposeTerminal(pending.terminalId, 'Terminal closed.');
+        pending.resolve();
+    }
+    handleOutputEvent(msg) {
+        const existingBuffer = this.bufferedOutputByTerminalId.get(msg.terminalId);
+        if (existingBuffer !== undefined) {
+            this.bufferedOutputByTerminalId.set(msg.terminalId, `${existingBuffer}${msg.data}`);
+        }
+        else if (!this.routesByTerminalId.has(msg.terminalId) && this.hasPendingBufferedCreate()) {
+            this.bufferedOutputByTerminalId.set(msg.terminalId, msg.data);
+        }
+        this.broadcast(msg.terminalId, {
+            type: 'output',
+            terminalId: msg.terminalId,
+            data: msg.data,
+        });
+        this.emitOutput({ terminalId: msg.terminalId, data: msg.data });
+    }
+    handleExitEvent(msg) {
+        this.broadcast(msg.terminalId, {
+            type: 'exit',
+            terminalId: msg.terminalId,
+            exitCode: msg.exitCode,
+            signal: msg.signal,
+        });
+        this.emitTermination({
+            terminalId: msg.terminalId,
+            exitCode: msg.exitCode,
+            signal: msg.signal,
+            disposed: false,
+        });
+    }
+    rejectPendingForNode(nodeId) {
+        for (const [requestId, pending] of this.pending.entries()) {
+            if (pending.nodeId !== nodeId)
+                continue;
+            clearTimeout(pending.timer);
+            pending.reject(new Error(`Agent node disconnected: ${nodeId}`));
+            this.pending.delete(requestId);
+        }
+    }
+    handleNodeDisconnect(nodeId) {
+        this.rejectPendingForNode(nodeId);
+        for (const [terminalId, route] of this.routesByTerminalId.entries()) {
+            if (route.nodeId !== nodeId)
+                continue;
+            this.disposeTerminal(terminalId, `Agent node disconnected: ${nodeId}`);
+        }
+    }
+    sendNoContentRequest(nodeId, kind, msg) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(msg.requestId);
+                reject(new Error(`Terminal ${kind} request timed out.`));
+            }, this.timeoutMs);
+            this.pending.set(msg.requestId, { nodeId, kind, resolve, reject, timer });
+            const sent = this.nodeRegistry.send(nodeId, msg);
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(msg.requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    handleAckResponse(requestId, errorCode, error, kind) {
+        const pending = this.pending.get(requestId);
+        if (!pending || pending.kind !== kind)
+            return;
+        this.pending.delete(requestId);
+        clearTimeout(pending.timer);
+        if (error) {
+            pending.reject(new Error(formatTerminalError(errorCode, error)));
+            return;
+        }
+        pending.resolve();
+    }
+    hasPendingBufferedCreate() {
+        for (const pending of this.pending.values()) {
+            if (pending.kind === 'create' && pending.bufferOutputUntilTaken) {
+                return true;
+            }
+        }
+        return false;
+    }
+    trackTerminal(terminal, nodeId) {
+        this.routesByTerminalId.set(terminal.terminalId, {
+            nodeId,
+            workspaceRoot: terminal.workspaceRoot,
+        });
+    }
+    disposeTerminal(terminalId, reason) {
+        this.broadcast(terminalId, {
+            type: 'error',
+            message: reason,
+        });
+        this.bufferedOutputByTerminalId.delete(terminalId);
+        this.routesByTerminalId.delete(terminalId);
+        this.emitTermination({
+            terminalId,
+            reason,
+            disposed: true,
+        });
+        const sockets = this.socketsByTerminalId.get(terminalId);
+        if (!sockets)
+            return;
+        this.socketsByTerminalId.delete(terminalId);
+        for (const socket of sockets) {
+            if (socket.readyState === socket.OPEN || socket.readyState === socket.CONNECTING) {
+                socket.close();
+            }
+        }
+    }
+    broadcast(terminalId, event) {
+        const sockets = this.socketsByTerminalId.get(terminalId);
+        if (!sockets)
+            return;
+        const payload = JSON.stringify(event);
+        for (const socket of sockets) {
+            if (socket.readyState === socket.OPEN) {
+                socket.send(payload);
+            }
+        }
+    }
+    emitTermination(event) {
+        for (const listener of this.terminationListeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // Listener failures must not break terminal routing.
+            }
+        }
+    }
+    emitOutput(event) {
+        for (const listener of this.outputListeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // Listener failures must not break terminal routing.
+            }
+        }
+    }
+}
+function formatTerminalError(errorCode, error) {
+    if (errorCode)
+        return `${errorCode}:${error ?? 'terminal request failed'}`;
+    return error ?? 'terminal request failed';
+}

package/dist/services/workspaceRunOwnership.js

@@ -0,0 +1,60 @@
+export const WORKSPACE_RUN_DISPATCH_METHOD = 'workspace/run.dispatch';
+const WORKSPACE_RUN_DISPATCH_SEQ = -1;
+export function persistWorkspaceRunDispatchContext(db, runId, context) {
+    db.prepare(`INSERT OR REPLACE INTO events(run_id, seq, method, payload_json, created_at)
+     VALUES(?, ?, ?, ?, ?)`).run(runId, WORKSPACE_RUN_DISPATCH_SEQ, WORKSPACE_RUN_DISPATCH_METHOD, JSON.stringify(context), Date.now());
+}
+export function getWorkspaceRunDispatchContext(db, runId) {
+    const row = db.prepare(`SELECT payload_json as payloadJson
+       FROM events
+      WHERE run_id = ?
+        AND method = ?
+      LIMIT 1`).get(runId, WORKSPACE_RUN_DISPATCH_METHOD);
+    if (!row)
+        return null;
+    try {
+        const parsed = JSON.parse(row.payloadJson);
+        if (typeof parsed.nodeId !== 'string'
+            || !parsed.nodeId.trim()
+            || typeof parsed.workspaceSessionId !== 'string'
+            || typeof parsed.agentId !== 'string'
+            || typeof parsed.workspaceRootId !== 'string') {
+            return null;
+        }
+        return {
+            nodeId: parsed.nodeId,
+            workspaceSessionId: parsed.workspaceSessionId,
+            agentId: parsed.agentId,
+            workspaceRootId: parsed.workspaceRootId,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function getWorkspaceRunDispatchNodeId(db, runId) {
+    return getWorkspaceRunDispatchContext(db, runId)?.nodeId ?? null;
+}
+export function getWorkspaceSessionOwnerNodeId(db, sessionKey) {
+    const row = db.prepare(`SELECT owner.payload_json as payloadJson
+       FROM runs r
+       JOIN events owner ON owner.run_id = r.run_id
+      WHERE r.session_key = ?
+        AND owner.method = ?
+        AND json_valid(owner.payload_json)
+        AND COALESCE(json_extract(owner.payload_json, '$.nodeId'), '') != ''
+        AND (r.ended_at IS NULL OR r.error IS NULL)
+      ORDER BY r.started_at DESC, owner.created_at DESC, r.run_id DESC
+      LIMIT 1`).get(sessionKey, WORKSPACE_RUN_DISPATCH_METHOD);
+    if (!row)
+        return null;
+    try {
+        const parsed = JSON.parse(row.payloadJson);
+        return typeof parsed.nodeId === 'string' && parsed.nodeId.trim()
+            ? parsed.nodeId
+            : null;
+    }
+    catch {
+        return null;
+    }
+}