@bbigbang/core 0.1.0

package/dist/services/agentWorkspaceBroker.js

@@ -0,0 +1,937 @@
+import { randomUUID } from 'node:crypto';
+import { PassThrough } from 'node:stream';
+export class AgentWorkspaceBroker {
+    pending = new Map();
+    nodeRegistry;
+    timeoutMs;
+    libraryMirrorTimeoutMs;
+    constructor(params) {
+        this.nodeRegistry = params.nodeRegistry;
+        this.timeoutMs = params.timeoutMs ?? 5_000;
+        this.libraryMirrorTimeoutMs = params.libraryMirrorTimeoutMs ?? Math.max(this.timeoutMs, 60_000);
+    }
+    listDirectory(nodeId, workspaceRoot, relativePath, options) {
+        const requestId = randomUUID();
+        const timeoutMs = typeof options?.timeoutMs === 'number' && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
+            ? options.timeoutMs
+            : this.timeoutMs;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Workspace request timed out.'));
+            }, timeoutMs);
+            this.pending.set(requestId, {
+                kind: 'list',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'workspace.list.request',
+                requestId,
+                workspaceRoot,
+                relativePath,
+                ...(options?.runId?.trim() ? { runId: options.runId.trim() } : {}),
+                ...(options?.scaffold === false ? { scaffold: false } : {}),
+                ...(options?.agentName?.trim() ? { agentName: options.agentName.trim() } : {}),
+                ...(options?.cursor ? { cursor: options.cursor } : {}),
+                ...(typeof options?.limit === 'number' ? { limit: options.limit } : {}),
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    readFile(nodeId, workspaceRoot, relativePath, options) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Workspace request timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, {
+                kind: 'read',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'workspace.read.request',
+                requestId,
+                workspaceRoot,
+                relativePath,
+                ...(options?.runId?.trim() ? { runId: options.runId.trim() } : {}),
+                ...(options?.scaffold === false ? { scaffold: false } : {}),
+                ...(options?.agentName?.trim() ? { agentName: options.agentName.trim() } : {}),
+                ...(typeof options?.offset === 'number' ? { offset: options.offset } : {}),
+                ...(typeof options?.limit === 'number' ? { limit: options.limit } : {}),
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    archiveDirectory(nodeId, workspaceRoot, relativePath, options) {
+        const requestId = randomUUID();
+        const timeoutMs = typeof options?.timeoutMs === 'number' && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
+            ? options.timeoutMs
+            : Math.max(this.timeoutMs, 60_000);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Workspace archive request timed out.'));
+            }, timeoutMs);
+            this.pending.set(requestId, {
+                kind: 'archive',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'workspace.archive.request',
+                requestId,
+                workspaceRoot,
+                relativePath,
+                ...(typeof options?.maxBytes === 'number' ? { maxBytes: options.maxBytes } : {}),
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    extractDirectoryArchive(nodeId, workspaceRoot, relativePath, archiveBase64, options) {
+        const requestId = randomUUID();
+        const timeoutMs = typeof options?.timeoutMs === 'number' && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
+            ? options.timeoutMs
+            : Math.max(this.timeoutMs, 60_000);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Workspace extract request timed out.'));
+            }, timeoutMs);
+            this.pending.set(requestId, {
+                kind: 'extract',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'workspace.extract.request',
+                requestId,
+                workspaceRoot,
+                relativePath,
+                archiveBase64,
+                ...(options?.overwrite === true ? { overwrite: true } : {}),
+                ...(typeof options?.maxBytes === 'number' ? { maxBytes: options.maxBytes } : {}),
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    readExactPath(nodeId, absolutePath, options = {}) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Workspace request timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, {
+                kind: 'read-path',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'fs.read_path.request',
+                requestId,
+                absolutePath,
+                ...(options.allowedRoot ? { allowedRoot: options.allowedRoot } : {}),
+                ...(options.trustedRoot ? { trustedRoot: options.trustedRoot } : {}),
+                ...(options.cursor ? { cursor: options.cursor } : {}),
+                ...(typeof options.offset === 'number' ? { offset: options.offset } : {}),
+                ...(typeof options.limit === 'number' ? { limit: options.limit } : {}),
+                ...(typeof options.maxPreviewBytes === 'number' ? { maxPreviewBytes: options.maxPreviewBytes } : {}),
+                ...(options.rawContentBase64 ? { rawContentBase64: true } : {}),
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    suggestPaths(nodeId, query, options = {}) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Workspace request timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, {
+                kind: 'path-suggest',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'fs.path_suggest.request',
+                requestId,
+                query,
+                ...(typeof options.limit === 'number' ? { limit: options.limit } : {}),
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    fetchHttpText(nodeId, url, options = {}) {
+        const requestId = randomUUID();
+        const timeoutMs = typeof options.timeoutMs === 'number' && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
+            ? options.timeoutMs
+            : this.timeoutMs;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('HTTP fetch request timed out.'));
+            }, timeoutMs);
+            this.pending.set(requestId, {
+                kind: 'http-fetch-text',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'http.fetch_text.request',
+                requestId,
+                url,
+                ...(typeof options.maxBytes === 'number' ? { maxBytes: options.maxBytes } : {}),
+                ...(typeof options.authProfile === 'string' && options.authProfile.trim() ? { authProfile: options.authProfile.trim() } : {}),
+                ...(typeof options.ifNoneMatch === 'string' && options.ifNoneMatch.trim() ? { ifNoneMatch: options.ifNoneMatch.trim() } : {}),
+                ...(typeof options.ifModifiedSince === 'string' && options.ifModifiedSince.trim() ? { ifModifiedSince: options.ifModifiedSince.trim() } : {}),
+                ...(typeof options.ifRange === 'string' && options.ifRange.trim() ? { ifRange: options.ifRange.trim() } : {}),
+                ...(typeof options.rangeStart === 'number' && Number.isInteger(options.rangeStart) && options.rangeStart >= 0 ? { rangeStart: options.rangeStart } : {}),
+                ...(typeof options.rangeLength === 'number' && Number.isInteger(options.rangeLength) && options.rangeLength > 0 ? { rangeLength: options.rangeLength } : {}),
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    proxyWorkspaceService(nodeId, url, options = {}) {
+        const requestId = randomUUID();
+        const timeoutMs = typeof options.timeoutMs === 'number' && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
+            ? options.timeoutMs
+            : this.timeoutMs;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Workspace service proxy request timed out.'));
+            }, timeoutMs);
+            this.pending.set(requestId, {
+                kind: 'workspace-service-proxy',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'workspace.service_proxy.request',
+                requestId,
+                url,
+                ...(options.method ? { method: options.method } : {}),
+                ...(options.headers ? { headers: options.headers } : {}),
+                ...(typeof options.body === 'string' ? { body: options.body } : {}),
+                ...(typeof options.maxBytes === 'number' ? { maxBytes: options.maxBytes } : {}),
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    streamExactPath(nodeId, absolutePath, options = {}) {
+        const requestId = randomUUID();
+        const stream = new PassThrough();
+        stream.on('error', () => {
+            // Keep broker-created streams from surfacing as unhandled errors before
+            // Fastify has attached its own response pipeline listeners.
+        });
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.failStreamRequest(requestId, new Error('Workspace stream request timed out.'));
+            }, Math.min(this.timeoutMs, 2_000));
+            this.pending.set(requestId, {
+                kind: 'read-path-stream',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+                stream,
+                started: false,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'fs.read_path.stream.request',
+                requestId,
+                absolutePath,
+                ...(options.allowedRoot ? { allowedRoot: options.allowedRoot } : {}),
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                stream.destroy();
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    writeFile(nodeId, workspaceRoot, relativePath, content, mode, options) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Workspace write request timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, {
+                kind: 'write',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'workspace.write.request',
+                requestId,
+                workspaceRoot,
+                relativePath,
+                content,
+                mode,
+                ...(options?.contentEncoding ? { contentEncoding: options.contentEncoding } : {}),
+                ...(options?.scaffold === false ? { scaffold: false } : {}),
+                ...(options?.agentName?.trim() ? { agentName: options.agentName.trim() } : {}),
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    deleteFile(nodeId, workspaceRoot, relativePath) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Workspace delete request timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, {
+                kind: 'delete-file',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'workspace.delete_file.request',
+                requestId,
+                workspaceRoot,
+                relativePath,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    deletePath(nodeId, workspaceRoot, relativePath, options) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Workspace delete request timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, {
+                kind: 'delete-path',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'workspace.delete_path.request',
+                requestId,
+                workspaceRoot,
+                relativePath,
+                ...(options?.recursive === true ? { recursive: true } : {}),
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    resetWorkspace(nodeId, workspaceRoot, options) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Workspace reset timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, {
+                kind: 'reset',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'workspace.reset.request',
+                requestId,
+                workspaceRoot,
+                ...(options?.agentName?.trim() ? { agentName: options.agentName.trim() } : {}),
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    applyLibraryMirror(nodeId, workspaceRoot, mirror) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Library mirror apply timed out.'));
+            }, this.libraryMirrorTimeoutMs);
+            this.pending.set(requestId, {
+                kind: 'library-mirror-apply',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'library.mirror.apply.request',
+                requestId,
+                workspaceRoot,
+                shared: mirror.shared,
+                personal: mirror.personal,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    snapshotLibraryMirror(nodeId, workspaceRoot) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Library mirror snapshot timed out.'));
+            }, this.libraryMirrorTimeoutMs);
+            this.pending.set(requestId, {
+                kind: 'library-mirror-snapshot',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'library.mirror.snapshot.request',
+                requestId,
+                workspaceRoot,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    deleteLibraryPath(nodeId, libraryRoot, relativePath, options) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Library authority delete timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, {
+                kind: 'library-authority-delete',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'library.authority.delete.request',
+                requestId,
+                libraryRoot,
+                relativePath,
+                ...(options?.recursive ? { recursive: true } : {}),
+                ...(options?.agentName?.trim() ? { agentName: options.agentName.trim() } : {}),
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    renameLibraryPath(nodeId, libraryRoot, relativePath, nextRelativePath, options) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Library authority rename timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, {
+                kind: 'library-authority-rename',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'library.authority.rename.request',
+                requestId,
+                libraryRoot,
+                relativePath,
+                nextRelativePath,
+                ...(options?.agentName?.trim() ? { agentName: options.agentName.trim() } : {}),
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    handleWorkspaceListResponse(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.entries) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve({
+            path: msg.relativePath,
+            entries: msg.entries,
+            directoryPage: msg.directoryPage ?? {
+                nextCursor: null,
+                hasMore: false,
+                limit: msg.entries.length,
+            },
+        });
+    }
+    handleWorkspaceReadResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'read')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || msg.content === undefined || !msg.mimeType || msg.size === undefined) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        const result = {
+            path: msg.relativePath,
+            content: msg.content,
+            mimeType: msg.mimeType,
+            size: msg.size,
+            modifiedAt: msg.modifiedAt ?? null,
+        };
+        if (msg.offset !== undefined)
+            result.offset = msg.offset;
+        if (msg.limit !== undefined)
+            result.limit = msg.limit;
+        if (msg.nextOffset !== undefined)
+            result.nextOffset = msg.nextOffset;
+        if (msg.hasMore !== undefined)
+            result.hasMore = msg.hasMore;
+        pending.resolve(result);
+    }
+    handleWorkspaceArchiveResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'archive')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || msg.archiveBase64 === undefined || msg.byteSize === undefined || msg.fileCount === undefined) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve({
+            path: msg.relativePath,
+            archiveBase64: msg.archiveBase64,
+            byteSize: msg.byteSize,
+            fileCount: msg.fileCount,
+        });
+    }
+    handleWorkspaceExtractResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'extract')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.ok || msg.byteSize === undefined || msg.fileCount === undefined) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve({
+            path: msg.relativePath,
+            byteSize: msg.byteSize,
+            fileCount: msg.fileCount,
+        });
+    }
+    handleWorkspaceDeleteFileResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'delete-file')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.ok) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve();
+    }
+    handleWorkspaceDeletePathResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'delete-path')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.ok) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve();
+    }
+    handleFsReadPathResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'read-path')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.kind) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        if (msg.kind === 'directory') {
+            pending.resolve({
+                absolutePath: msg.absolutePath,
+                kind: 'directory',
+                entries: msg.entries ?? [],
+                directoryPage: msg.directoryPage ?? {
+                    nextCursor: null,
+                    hasMore: false,
+                    limit: msg.entries?.length ?? 0,
+                },
+                modifiedAt: msg.modifiedAt ?? null,
+            });
+            return;
+        }
+        if (msg.kind === 'file') {
+            if (msg.content === undefined || !msg.mimeType || msg.size === undefined) {
+                pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+                return;
+            }
+            const result = {
+                absolutePath: msg.absolutePath,
+                kind: 'file',
+                content: msg.content,
+                mimeType: msg.mimeType,
+                size: msg.size,
+                modifiedAt: msg.modifiedAt ?? null,
+            };
+            if (msg.offset !== undefined)
+                result.offset = msg.offset;
+            if (msg.limit !== undefined)
+                result.limit = msg.limit;
+            if (msg.nextOffset !== undefined)
+                result.nextOffset = msg.nextOffset;
+            if (msg.hasMore !== undefined)
+                result.hasMore = msg.hasMore;
+            if (msg.rawContentBase64 !== undefined)
+                result.rawContentBase64 = msg.rawContentBase64;
+            pending.resolve(result);
+            return;
+        }
+        pending.resolve({
+            absolutePath: msg.absolutePath,
+            kind: msg.kind,
+            modifiedAt: msg.modifiedAt ?? null,
+        });
+    }
+    handleFsPathSuggestResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'path-suggest')
+            return;
+        clearTimeout(pending.timer);
+        this.pending.delete(msg.requestId);
+        if (msg.error) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve({
+            query: msg.query,
+            suggestions: msg.suggestions ?? [],
+        });
+    }
+    handleHttpFetchTextResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'http-fetch-text')
+            return;
+        clearTimeout(pending.timer);
+        this.pending.delete(msg.requestId);
+        if (msg.error || msg.status === undefined) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        if (msg.notModified || msg.status === 304) {
+            pending.resolve({
+                url: msg.url,
+                content: msg.content ?? '',
+                status: msg.status,
+                contentType: msg.contentType ?? null,
+                size: msg.size ?? 0,
+                ...(msg.partialContent !== undefined ? { partialContent: msg.partialContent } : {}),
+                ...(msg.rangeStart !== undefined ? { rangeStart: msg.rangeStart } : {}),
+                ...(msg.rangeEnd !== undefined ? { rangeEnd: msg.rangeEnd } : {}),
+                ...(msg.totalSize !== undefined ? { totalSize: msg.totalSize ?? null } : {}),
+                ...(msg.hasMore !== undefined ? { hasMore: msg.hasMore } : {}),
+                notModified: true,
+                etag: msg.etag ?? null,
+                lastModified: msg.lastModified ?? null,
+            });
+            return;
+        }
+        if (msg.content === undefined || msg.size === undefined) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve({
+            url: msg.url,
+            content: msg.content,
+            status: msg.status,
+            contentType: msg.contentType ?? null,
+            size: msg.size,
+            ...(msg.partialContent !== undefined ? { partialContent: msg.partialContent } : {}),
+            ...(msg.rangeStart !== undefined ? { rangeStart: msg.rangeStart } : {}),
+            ...(msg.rangeEnd !== undefined ? { rangeEnd: msg.rangeEnd } : {}),
+            ...(msg.totalSize !== undefined ? { totalSize: msg.totalSize ?? null } : {}),
+            ...(msg.hasMore !== undefined ? { hasMore: msg.hasMore } : {}),
+            etag: msg.etag ?? null,
+            lastModified: msg.lastModified ?? null,
+        });
+    }
+    handleWorkspaceServiceProxyResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'workspace-service-proxy')
+            return;
+        clearTimeout(pending.timer);
+        this.pending.delete(msg.requestId);
+        if (msg.error || msg.status === undefined || msg.body === undefined || msg.size === undefined) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve({
+            url: msg.url,
+            method: msg.method,
+            status: msg.status,
+            body: msg.body,
+            contentType: msg.contentType ?? null,
+            size: msg.size,
+        });
+    }
+    handleFsReadPathStreamStart(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'read-path-stream')
+            return;
+        pending.started = true;
+        clearTimeout(pending.timer);
+        pending.timer = this.createStreamIdleTimer(msg.requestId);
+        pending.resolve({
+            absolutePath: msg.absolutePath,
+            mimeType: msg.mimeType,
+            size: msg.size,
+            modifiedAt: msg.modifiedAt ?? null,
+            stream: pending.stream,
+        });
+    }
+    handleFsReadPathStreamChunk(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'read-path-stream')
+            return;
+        clearTimeout(pending.timer);
+        pending.timer = this.createStreamIdleTimer(msg.requestId);
+        pending.stream.write(Buffer.from(msg.chunk, 'base64'));
+    }
+    handleFsReadPathStreamEnd(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'read-path-stream')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error) {
+            const error = new Error(this.formatErrorMessage(msg.errorCode, msg.error));
+            if (pending.started) {
+                pending.stream.destroy(error);
+            }
+            else {
+                pending.stream.destroy();
+                pending.reject(error);
+            }
+            return;
+        }
+        pending.stream.end();
+    }
+    handleWorkspaceResetResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'reset')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.ok) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve();
+    }
+    handleLibraryMirrorApplyResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'library-mirror-apply')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.ok) {
+            pending.reject(new Error(msg.error ?? 'library mirror apply failed'));
+            return;
+        }
+        pending.resolve();
+    }
+    handleLibraryMirrorSnapshotResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'library-mirror-snapshot')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error) {
+            pending.reject(new Error(msg.error));
+            return;
+        }
+        pending.resolve({
+            shared: msg.shared ?? null,
+            personal: msg.personal ?? null,
+        });
+    }
+    handleLibraryAuthorityDeleteResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'library-authority-delete')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.ok) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve();
+    }
+    handleLibraryAuthorityRenameResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'library-authority-rename')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.ok) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve();
+    }
+    handleWorkspaceWriteResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'write')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.ok) {
+            pending.reject(new Error(this.formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve();
+    }
+    rejectPendingForNode(nodeId) {
+        for (const [requestId, pending] of this.pending.entries()) {
+            if (pending.nodeId !== nodeId)
+                continue;
+            clearTimeout(pending.timer);
+            const error = new Error(`Agent node disconnected: ${nodeId}`);
+            if (pending.kind === 'read-path-stream') {
+                if (pending.started) {
+                    pending.stream.destroy(error);
+                }
+                else {
+                    pending.stream.destroy();
+                    pending.reject(error);
+                }
+            }
+            else {
+                pending.reject(error);
+            }
+            this.pending.delete(requestId);
+        }
+    }
+    createStreamIdleTimer(requestId) {
+        return setTimeout(() => {
+            this.failStreamRequest(requestId, new Error('Workspace stream request timed out.'));
+        }, this.timeoutMs);
+    }
+    failStreamRequest(requestId, error) {
+        const pending = this.pending.get(requestId);
+        if (!pending || pending.kind !== 'read-path-stream')
+            return;
+        this.pending.delete(requestId);
+        clearTimeout(pending.timer);
+        if (pending.started) {
+            pending.stream.destroy(error);
+        }
+        else {
+            pending.stream.destroy();
+            pending.reject(error);
+        }
+    }
+    formatErrorMessage(errorCode, error) {
+        if (errorCode) {
+            return `${errorCode}:${error ?? 'workspace request failed'}`;
+        }
+        return error ?? 'workspace request failed';
+    }
+}