@bbigbang/core 0.1.0

package/dist/services/projectAccessResolver.js

@@ -0,0 +1,93 @@
+export class ProjectAccessResolverError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+export class ProjectAccessResolver {
+    projectService;
+    nodeRegistry;
+    workspaceBroker;
+    preferredNodeByProjectId = new Map();
+    constructor(params) {
+        this.projectService = params.projectService;
+        this.nodeRegistry = params.nodeRegistry;
+        this.workspaceBroker = params.workspaceBroker;
+    }
+    getCandidateNodeIds(projectId) {
+        const project = this.projectService.getProject(projectId);
+        if (!project)
+            throw new ProjectAccessResolverError(404, 'Project not found.');
+        if (project.backendType === 'local_path') {
+            if (!project.nodeId) {
+                throw new ProjectAccessResolverError(409, 'Project is missing its node binding.');
+            }
+            return [project.nodeId];
+        }
+        const onlineNodeIds = this.projectService
+            .getProjectCandidateNodeIds(projectId)
+            .filter((nodeId) => !!this.nodeRegistry.getNode(nodeId));
+        const stickyNodeId = this.preferredNodeByProjectId.get(projectId) ?? null;
+        const preferredNodeIds = stickyNodeId && onlineNodeIds.includes(stickyNodeId)
+            ? [stickyNodeId]
+            : [];
+        const fallbackNodeIds = onlineNodeIds.filter((nodeId) => nodeId !== stickyNodeId);
+        const candidateNodeIds = [...preferredNodeIds, ...fallbackNodeIds];
+        if (candidateNodeIds.length === 0) {
+            throw new ProjectAccessResolverError(409, 'No online node can currently access this shared project.');
+        }
+        return candidateNodeIds;
+    }
+    getTerminalCandidateNodeIds(projectId) {
+        return this.getCandidateNodeIds(projectId)
+            .filter((nodeId) => Boolean(this.nodeRegistry.getNode(nodeId)?.terminalBackendAvailable));
+    }
+    async verifySharedBinding(projectId, nodeId) {
+        const project = this.projectService.getProject(projectId);
+        if (!project)
+            throw new ProjectAccessResolverError(404, 'Project not found.');
+        try {
+            await this.workspaceBroker.listDirectory(nodeId, project.rootPath, '', { scaffold: false });
+            this.preferredNodeByProjectId.set(projectId, nodeId);
+        }
+        catch (error) {
+            throw new ProjectAccessResolverError(409, `Node ${nodeId} cannot currently access shared project ${project.rootPath}: ${String(error?.message ?? error)}`);
+        }
+    }
+    async withResolvedNode(projectId, operation, options) {
+        const project = this.projectService.getProject(projectId);
+        if (!project)
+            throw new ProjectAccessResolverError(404, 'Project not found.');
+        const candidateNodeIds = this.getCandidateNodeIds(projectId);
+        let lastError = null;
+        const attempts = [];
+        for (const nodeId of candidateNodeIds) {
+            try {
+                const result = await operation(nodeId);
+                if (project.backendType === 'shared_mount') {
+                    this.preferredNodeByProjectId.set(projectId, nodeId);
+                }
+                return result;
+            }
+            catch (error) {
+                lastError = error;
+                attempts.push(`${nodeId} -> ${String(error?.message ?? error)}`);
+                if (project.backendType === 'shared_mount' && shouldRetryOnNextNode(error, options?.retryOnTransportOnly ?? true)) {
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw new ProjectAccessResolverError(409, attempts.length > 0 ? `Unable to access shared project. Attempts: ${attempts.join(' | ')}` : 'Project access failed.');
+    }
+}
+function shouldRetryOnNextNode(error, retryOnTransportOnly) {
+    if (!retryOnTransportOnly)
+        return true;
+    const message = String(error?.message ?? error);
+    return (message === 'Agent node is offline.'
+        || message === 'Workspace request timed out.'
+        || message.startsWith('io_error:')
+        || message.startsWith('Agent node disconnected:'));
+}

package/dist/services/projectService.js

@@ -0,0 +1,392 @@
+import { randomUUID } from 'node:crypto';
+import { getWorkbenchPathBasename, isAbsoluteWorkbenchRootPath } from './workbenchRootService.js';
+export class ProjectServiceError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+export class ProjectService {
+    db;
+    workspaceBroker;
+    getAgentById;
+    constructor(params) {
+        this.db = params.db;
+        this.workspaceBroker = params.workspaceBroker;
+        this.getAgentById = params.getAgentById;
+    }
+    listProjects() {
+        const rows = this.db.prepare(`SELECT project_id as projectId,
+              name,
+              backend_type as backendType,
+              root_path as rootPath,
+              node_id as nodeId,
+              description,
+              created_at as createdAt,
+              updated_at as updatedAt,
+              archived_at as archivedAt
+         FROM projects
+        WHERE archived_at IS NULL
+        ORDER BY updated_at DESC, name COLLATE NOCASE ASC`).all();
+        return rows.map((row) => this.rowToProjectInfo(row));
+    }
+    getProject(projectId) {
+        const row = this.getProjectRow(projectId);
+        return row ? this.rowToProjectInfo(row) : null;
+    }
+    getProjectBindingsForAgent(agentId) {
+        const rows = this.db.prepare(`SELECT p.project_id as projectId,
+              p.name,
+              p.backend_type as backendType,
+              p.root_path as rootPath,
+              p.node_id as nodeId,
+              p.description as description,
+              b.is_default as isDefault
+         FROM agent_project_bindings b
+         JOIN projects p ON p.project_id = b.project_id
+        WHERE b.agent_id = ?
+          AND p.archived_at IS NULL
+        ORDER BY b.is_default DESC, p.updated_at DESC, p.name COLLATE NOCASE ASC`).all(agentId);
+        return rows.map((row) => ({
+            projectId: row.projectId,
+            name: row.name,
+            backendType: row.backendType,
+            rootPath: row.rootPath,
+            nodeId: row.nodeId,
+            description: row.description,
+            isDefault: row.isDefault !== 0,
+        }));
+    }
+    createProject(req) {
+        const name = req.name.trim();
+        const rootPath = req.rootPath.trim();
+        const backendType = req.backendType;
+        const nodeId = normalizeNullableString(req.nodeId);
+        const description = normalizeNullableString(req.description);
+        if (!name)
+            throw new ProjectServiceError(400, 'Project name is required.');
+        if (!rootPath || !isAbsoluteWorkbenchRootPath(rootPath)) {
+            throw new ProjectServiceError(400, 'Project rootPath must be an absolute path.');
+        }
+        this.assertBackendConfiguration(backendType, nodeId);
+        const projectId = randomUUID();
+        const now = Date.now();
+        this.db.prepare(`INSERT INTO projects(
+         project_id,
+         name,
+         backend_type,
+         root_path,
+         node_id,
+         description,
+         created_at,
+         updated_at,
+         archived_at
+       ) VALUES(?, ?, ?, ?, ?, ?, ?, ?, NULL)`).run(projectId, name, backendType, rootPath, nodeId, description, now, now);
+        return this.getProject(projectId);
+    }
+    updateProject(projectId, req) {
+        const existing = this.getProjectRow(projectId);
+        if (!existing)
+            throw new ProjectServiceError(404, 'Project not found.');
+        const name = 'name' in req ? req.name?.trim() || existing.name : existing.name;
+        const backendType = req.backendType ?? existing.backendType;
+        const rootPath = 'rootPath' in req ? req.rootPath?.trim() || existing.rootPath : existing.rootPath;
+        const nodeId = 'nodeId' in req ? normalizeNullableString(req.nodeId) : existing.nodeId;
+        const description = 'description' in req ? normalizeNullableString(req.description) : existing.description;
+        if (!name)
+            throw new ProjectServiceError(400, 'Project name is required.');
+        if (!rootPath || !isAbsoluteWorkbenchRootPath(rootPath)) {
+            throw new ProjectServiceError(400, 'Project rootPath must be an absolute path.');
+        }
+        this.assertBackendConfiguration(backendType, nodeId);
+        if (backendType === 'local_path') {
+            const boundAgents = this.listBoundAgents(projectId);
+            const invalid = boundAgents.find((agent) => (agent.nodeId ?? null) !== nodeId);
+            if (invalid) {
+                throw new ProjectServiceError(409, `Agent ${invalid.name} is bound to a different node and cannot stay attached to this local-path project.`);
+            }
+        }
+        this.db.prepare(`UPDATE projects
+          SET name = ?,
+              backend_type = ?,
+              root_path = ?,
+              node_id = ?,
+              description = ?,
+              updated_at = ?,
+              archived_at = NULL
+        WHERE project_id = ?`).run(name, backendType, rootPath, nodeId, description, Date.now(), projectId);
+        return this.getProject(projectId);
+    }
+    archiveProject(projectId) {
+        const existing = this.getProjectRow(projectId);
+        if (!existing)
+            throw new ProjectServiceError(404, 'Project not found.');
+        const now = Date.now();
+        this.db.prepare(`UPDATE projects
+          SET archived_at = ?, updated_at = ?
+        WHERE project_id = ?`).run(now, now, projectId);
+        this.db.prepare(`DELETE FROM agent_project_bindings WHERE project_id = ?`).run(projectId);
+        this.db.prepare(`UPDATE conversations
+          SET active_project_id = NULL, updated_at = ?
+        WHERE active_project_id = ?`).run(now, projectId);
+    }
+    async bindProjectToAgent(projectId, req) {
+        const project = this.getProjectRow(projectId);
+        if (!project)
+            throw new ProjectServiceError(404, 'Project not found.');
+        const agent = this.getAgentById(req.agentId);
+        if (!agent)
+            throw new ProjectServiceError(404, 'Agent not found.');
+        await this.assertBindingAllowed(agent, project);
+        const now = Date.now();
+        this.db.prepare(`INSERT INTO agent_project_bindings(
+         agent_id,
+         project_id,
+         is_default,
+         created_at,
+         updated_at
+       ) VALUES(?, ?, ?, ?, ?)
+       ON CONFLICT(agent_id, project_id) DO UPDATE SET
+         updated_at = excluded.updated_at,
+         is_default = CASE WHEN excluded.is_default != 0 THEN 1 ELSE agent_project_bindings.is_default END`).run(agent.agentId, projectId, req.isDefault ? 1 : 0, now, now);
+        if (req.isDefault) {
+            this.setAgentDefaultProject(agent.agentId, { projectId });
+        }
+        return this.getProject(projectId);
+    }
+    unbindProjectFromAgent(projectId, agentId) {
+        const binding = this.db.prepare(`SELECT 1
+         FROM agent_project_bindings
+        WHERE agent_id = ?
+          AND project_id = ?`).get(agentId, projectId);
+        if (!binding)
+            throw new ProjectServiceError(404, 'Project binding not found.');
+        this.db.prepare(`DELETE FROM agent_project_bindings
+        WHERE agent_id = ?
+          AND project_id = ?`).run(agentId, projectId);
+        this.db.prepare(`UPDATE conversations
+          SET active_project_id = NULL,
+              updated_at = ?
+        WHERE agent_id = ?
+          AND active_project_id = ?`).run(Date.now(), agentId, projectId);
+        this.archiveProjectIfUnbound(projectId);
+    }
+    setAgentDefaultProject(agentId, req) {
+        const projectId = normalizeNullableString(req.projectId);
+        const previousDefaultProjectId = this.db.prepare(`SELECT project_id as projectId
+         FROM agent_project_bindings
+        WHERE agent_id = ?
+          AND is_default != 0
+        LIMIT 1`).get(agentId);
+        if (projectId) {
+            const bindingExists = this.db.prepare(`SELECT 1
+           FROM agent_project_bindings
+          WHERE agent_id = ?
+            AND project_id = ?
+          LIMIT 1`).get(agentId, projectId);
+            if (!bindingExists)
+                throw new ProjectServiceError(404, 'Project binding not found.');
+        }
+        this.db.prepare(`UPDATE agent_project_bindings
+          SET is_default = 0,
+              updated_at = ?
+        WHERE agent_id = ?`).run(Date.now(), agentId);
+        if (projectId) {
+            this.db.prepare(`UPDATE agent_project_bindings
+            SET is_default = 1,
+                updated_at = ?
+          WHERE agent_id = ?
+            AND project_id = ?`).run(Date.now(), agentId, projectId);
+        }
+        const nextDefaultProjectId = projectId ?? null;
+        if ((previousDefaultProjectId?.projectId ?? null) !== nextDefaultProjectId) {
+            const now = Date.now();
+            if (nextDefaultProjectId) {
+                this.db.prepare(`UPDATE conversations
+              SET active_project_id = ?,
+                  updated_at = ?
+            WHERE agent_id = ?
+              AND (
+                active_project_id IS NULL
+                OR active_project_id = ?
+              )`).run(nextDefaultProjectId, now, agentId, previousDefaultProjectId?.projectId ?? null);
+            }
+            else if (previousDefaultProjectId?.projectId) {
+                this.db.prepare(`UPDATE conversations
+              SET active_project_id = NULL,
+                  updated_at = ?
+            WHERE agent_id = ?
+              AND active_project_id = ?`).run(now, agentId, previousDefaultProjectId.projectId);
+            }
+        }
+        return this.getProjectBindingsForAgent(agentId);
+    }
+    async replaceLegacyLocalProjectPath(agentId, previousProjectPath, nextProjectPath) {
+        const agent = this.getAgentById(agentId);
+        if (!agent?.nodeId)
+            return;
+        const previousPath = normalizeNullableString(previousProjectPath);
+        const nextPath = normalizeNullableString(nextProjectPath);
+        if (previousPath && (!nextPath || previousPath !== nextPath)) {
+            const legacyProject = this.findLegacyLocalProject(agent.nodeId, previousPath);
+            if (legacyProject) {
+                try {
+                    this.unbindProjectFromAgent(legacyProject.projectId, agentId);
+                }
+                catch {
+                    // Ignore stale legacy bindings during migration.
+                }
+            }
+        }
+        if (nextPath) {
+            const project = this.ensureLegacyLocalProject(agent, nextPath);
+            await this.bindProjectToAgent(project.projectId, { agentId, isDefault: true });
+        }
+        else {
+            this.setAgentDefaultProject(agentId, { projectId: null });
+        }
+    }
+    getProjectCandidateNodeIds(projectId) {
+        const project = this.getProjectRow(projectId);
+        if (!project)
+            return [];
+        if (project.backendType === 'local_path') {
+            return project.nodeId ? [project.nodeId] : [];
+        }
+        const nodeIds = new Set();
+        for (const agent of this.listBoundAgents(projectId)) {
+            if (agent.nodeId)
+                nodeIds.add(agent.nodeId);
+        }
+        return [...nodeIds];
+    }
+    isAgentBoundToProject(agentId, projectId) {
+        return !!this.db.prepare(`SELECT 1
+         FROM agent_project_bindings
+        WHERE agent_id = ?
+          AND project_id = ?
+        LIMIT 1`).get(agentId, projectId);
+    }
+    rowToProjectInfo(row) {
+        return {
+            projectId: row.projectId,
+            name: row.name,
+            backendType: row.backendType,
+            rootPath: row.rootPath,
+            nodeId: row.nodeId,
+            description: row.description,
+            boundAgents: this.listBoundAgents(row.projectId),
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+    }
+    getProjectRow(projectId) {
+        const row = this.db.prepare(`SELECT project_id as projectId,
+              name,
+              backend_type as backendType,
+              root_path as rootPath,
+              node_id as nodeId,
+              description,
+              created_at as createdAt,
+              updated_at as updatedAt,
+              archived_at as archivedAt
+         FROM projects
+        WHERE project_id = ?
+          AND archived_at IS NULL`).get(projectId);
+        return row ?? null;
+    }
+    listBoundAgents(projectId) {
+        const rows = this.db.prepare(`SELECT a.agent_id as agentId,
+              a.name as name,
+              a.node_id as nodeId,
+              b.is_default as isDefault
+	     FROM agent_project_bindings b
+	     JOIN agents a ON a.agent_id = b.agent_id
+	    WHERE b.project_id = ?
+	      AND a.deleted_at IS NULL
+	    ORDER BY b.is_default DESC, a.name COLLATE NOCASE ASC`).all(projectId);
+        return rows.map((row) => ({
+            agentId: row.agentId,
+            name: row.name,
+            nodeId: row.nodeId,
+            isDefault: row.isDefault !== 0,
+        }));
+    }
+    ensureLegacyLocalProject(agent, projectPath) {
+        const existing = this.findLegacyLocalProject(agent.nodeId ?? null, projectPath);
+        if (existing)
+            return existing;
+        if (!agent.nodeId) {
+            throw new ProjectServiceError(409, 'Agent must be assigned to a node before it can bind a local project.');
+        }
+        const now = Date.now();
+        const projectId = randomUUID();
+        this.db.prepare(`INSERT INTO projects(
+         project_id,
+         name,
+         backend_type,
+         root_path,
+         node_id,
+         description,
+         created_at,
+         updated_at,
+         archived_at
+       ) VALUES(?, ?, 'local_path', ?, ?, NULL, ?, ?, NULL)`).run(projectId, getWorkbenchPathBasename(projectPath) || projectPath, projectPath, agent.nodeId, now, now);
+        return this.getProject(projectId);
+    }
+    findLegacyLocalProject(nodeId, projectPath) {
+        if (!nodeId)
+            return null;
+        const row = this.db.prepare(`SELECT project_id as projectId
+         FROM projects
+        WHERE archived_at IS NULL
+          AND backend_type = 'local_path'
+          AND node_id = ?
+          AND root_path = ?
+        ORDER BY updated_at DESC
+        LIMIT 1`).get(nodeId, projectPath);
+        return row ? this.getProject(row.projectId) : null;
+    }
+    archiveProjectIfUnbound(projectId) {
+        const remaining = this.db.prepare(`SELECT 1
+         FROM agent_project_bindings
+        WHERE project_id = ?
+        LIMIT 1`).get(projectId);
+        if (remaining)
+            return;
+        this.db.prepare(`UPDATE projects
+          SET archived_at = ?,
+              updated_at = ?
+        WHERE project_id = ?`).run(Date.now(), Date.now(), projectId);
+    }
+    async assertBindingAllowed(agent, project) {
+        if (!agent.nodeId) {
+            throw new ProjectServiceError(409, 'Agent must be assigned to a node before binding a project.');
+        }
+        if (project.backendType === 'local_path') {
+            if (!project.nodeId) {
+                throw new ProjectServiceError(409, 'Local-path project is missing its node binding.');
+            }
+            if (project.nodeId !== agent.nodeId) {
+                throw new ProjectServiceError(409, 'Local-path projects can only bind agents on the same node.');
+            }
+            return;
+        }
+        try {
+            await this.workspaceBroker.listDirectory(agent.nodeId, project.rootPath, '', { scaffold: false });
+        }
+        catch (error) {
+            throw new ProjectServiceError(409, `Node ${agent.nodeId} cannot currently access shared project ${project.rootPath}: ${String(error?.message ?? error)}`);
+        }
+    }
+    assertBackendConfiguration(backendType, nodeId) {
+        if (backendType === 'local_path' && !nodeId) {
+            throw new ProjectServiceError(400, 'local_path projects require a nodeId.');
+        }
+    }
+}
+function normalizeNullableString(value) {
+    const trimmed = value?.trim() ?? '';
+    return trimmed ? trimmed : null;
+}

package/dist/services/resourceSpaceService.js

@@ -0,0 +1,140 @@
+export class ResourceSpaceServiceError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+export class ResourceSpaceService {
+    getResourceSpaceById;
+    broker;
+    nodeRegistry;
+    preferredSharedMountNodes = new Map();
+    constructor(params) {
+        this.getResourceSpaceById = params.getResourceSpaceById;
+        this.broker = params.broker;
+        this.nodeRegistry = params.nodeRegistry;
+    }
+    async listTree(resourceSpaceId, relativePath, options = {}) {
+        const resourceSpace = this.getResourceSpaceById(resourceSpaceId);
+        if (!resourceSpace)
+            throw new ResourceSpaceServiceError(404, 'Resource space not found.');
+        try {
+            return await this.withResolvedNode(resourceSpace, async (nodeId) => this.broker.listDirectory(nodeId, resourceSpace.rootPath, relativePath, { scaffold: false, ...options }));
+        }
+        catch (error) {
+            throw mapResourceSpaceError(error);
+        }
+    }
+    async readFile(resourceSpaceId, relativePath) {
+        const resourceSpace = this.getResourceSpaceById(resourceSpaceId);
+        if (!resourceSpace)
+            throw new ResourceSpaceServiceError(404, 'Resource space not found.');
+        try {
+            return await this.withResolvedNode(resourceSpace, async (nodeId) => this.broker.readFile(nodeId, resourceSpace.rootPath, relativePath, { scaffold: false }));
+        }
+        catch (error) {
+            throw mapResourceSpaceError(error);
+        }
+    }
+    async withResolvedNode(resourceSpace, operation) {
+        const candidateNodeIds = this.resolveCandidateNodeIds(resourceSpace);
+        let lastError = null;
+        const attemptSummaries = [];
+        for (const nodeId of candidateNodeIds) {
+            try {
+                const result = await operation(nodeId);
+                if (resourceSpace.backendType === 'shared_mount') {
+                    this.preferredSharedMountNodes.set(resourceSpace.resourceSpaceId, nodeId);
+                }
+                return result;
+            }
+            catch (error) {
+                lastError = error;
+                attemptSummaries.push(formatNodeAttemptSummary(nodeId, error));
+                if (resourceSpace.backendType === 'shared_mount' && canTryNextSharedNode(error)) {
+                    continue;
+                }
+                if (resourceSpace.backendType === 'node_path') {
+                    const mapped = mapResourceSpaceError(error);
+                    throw new ResourceSpaceServiceError(mapped.statusCode, `Node ${nodeId}: ${mapped.message}`);
+                }
+                throw error;
+            }
+        }
+        if (resourceSpace.backendType === 'shared_mount' && attemptSummaries.length > 0) {
+            const mapped = mapResourceSpaceError(lastError);
+            throw new ResourceSpaceServiceError(mapped.statusCode, `Unable to read shared resource space. Attempts: ${attemptSummaries.join(' | ')}`);
+        }
+        throw lastError ?? new Error('No node could access this resource space.');
+    }
+    resolveCandidateNodeIds(resourceSpace) {
+        if (resourceSpace.backendType === 'node_path') {
+            if (!resourceSpace.nodeId) {
+                throw new ResourceSpaceServiceError(409, 'Resource space is missing its node binding.');
+            }
+            return [resourceSpace.nodeId];
+        }
+        const onlineNodes = this.nodeRegistry
+            .listNodes()
+            .sort((a, b) => b.lastSeen - a.lastSeen);
+        const stickyNodeId = this.preferredSharedMountNodes.get(resourceSpace.resourceSpaceId) ?? null;
+        const preferredNodeId = stickyNodeId ?? resourceSpace.nodeId ?? null;
+        const preferred = preferredNodeId
+            ? onlineNodes.filter((node) => node.nodeId === preferredNodeId).map((node) => node.nodeId)
+            : [];
+        const fallbacks = onlineNodes
+            .filter((node) => node.nodeId !== preferredNodeId)
+            .map((node) => node.nodeId);
+        const candidateNodeIds = [...preferred, ...fallbacks];
+        if (candidateNodeIds.length === 0) {
+            throw new ResourceSpaceServiceError(409, 'No online node can currently access this shared resource space.');
+        }
+        return candidateNodeIds;
+    }
+}
+function canTryNextSharedNode(error) {
+    // Only retry on transport-/availability-level errors. Deterministic results
+    // (not_found, not_file, binary_file, file_too_large …) point at the file
+    // itself, so retrying on every other node just slows the request down and
+    // produces noisy multi-node attempt logs.
+    const message = String(error?.message ?? error);
+    return (message === 'Agent node is offline.'
+        || message === 'Workspace request timed out.'
+        || message.startsWith('io_error:'));
+}
+function mapResourceSpaceError(error) {
+    if (error instanceof ResourceSpaceServiceError) {
+        return error;
+    }
+    const message = String(error?.message ?? error);
+    if (message === 'Agent node is offline.') {
+        return new ResourceSpaceServiceError(409, message);
+    }
+    if (message === 'Workspace request timed out.') {
+        return new ResourceSpaceServiceError(504, message);
+    }
+    if (message.startsWith('not_found:')) {
+        return new ResourceSpaceServiceError(404, message.slice('not_found:'.length));
+    }
+    if (message.startsWith('path_outside_workspace:')) {
+        return new ResourceSpaceServiceError(400, message.slice('path_outside_workspace:'.length));
+    }
+    if (message.startsWith('binary_file:')) {
+        return new ResourceSpaceServiceError(415, message.slice('binary_file:'.length));
+    }
+    if (message.startsWith('file_too_large:')) {
+        return new ResourceSpaceServiceError(413, message.slice('file_too_large:'.length));
+    }
+    if (message.startsWith('not_directory:') || message.startsWith('not_file:')) {
+        return new ResourceSpaceServiceError(400, message.slice(message.indexOf(':') + 1));
+    }
+    if (message.startsWith('io_error:')) {
+        return new ResourceSpaceServiceError(500, message.slice('io_error:'.length));
+    }
+    return new ResourceSpaceServiceError(500, message);
+}
+function formatNodeAttemptSummary(nodeId, error) {
+    const mapped = mapResourceSpaceError(error);
+    return `${nodeId} -> ${mapped.message}`;
+}