@greppleai/grip 0.0.0-stage → 0.1.3

package/dist/daemon/workspace-runtime.js

@@ -0,0 +1,705 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdir as fsMkdir, lstat, open, readFile, realpath, rename, rm } from "node:fs/promises";
+import { basename, isAbsolute, relative, resolve, sep } from "node:path";
+import { createLspRuntimeState, createLspToolDefinitions } from "../core/lsp/integration.js";
+import { createManagedStdioConnectionFactory, resolveLspConnectionFactory } from "../core/lsp/transport.js";
+import { hashRemoteWorkspaceJson, } from "../core/remote-workspace-protocol/contract.js";
+import { RemoteWorkspaceRequestError, } from "../core/remote-workspace-protocol/session.js";
+import { withFileMutationQueue } from "../core/tools/file-mutation-queue.js";
+import { GRIP_SESSION_ENVIRONMENT_NAMES, LocalToolOperations, } from "../core/tools/operations.js";
+import { WorkspaceToolHost } from "../core/tools/workspace-tool-host.js";
+import { loadDaemonLspConfiguration } from "./lsp-config.js";
+import { redactDaemonText } from "./security.js";
+const PRIMITIVE_OPERATIONS = [
+    "workspace.access",
+    "workspace.read",
+    "workspace.write",
+    "workspace.mkdir",
+    "workspace.stat",
+    "workspace.readdir",
+    "workspace.glob",
+    "workspace.grep",
+    "workspace.detect_image_mime",
+    "workspace.exec",
+];
+const SECRET_ENVIRONMENT_SUFFIX = /_(?:API_KEY|TOKEN|SECRET|PASSWORD|PRIVATE_KEY|CREDENTIALS)$/iu;
+const BASELINE_ENVIRONMENT = process.platform === "win32"
+    ? ["PATH", "PATHEXT", "SYSTEMROOT", "COMSPEC", "TEMP", "TMP", "USER", "USERNAME"]
+    : ["PATH", "HOME", "USER", "LOGNAME", "SHELL", "LANG", "TERM", "COLORTERM", "NO_COLOR", "TMPDIR"];
+function isSecretEnvironmentName(name) {
+    const upper = name.toUpperCase();
+    return (upper === "GRIP_DAEMON_TOKEN" ||
+        upper === "PI_DAEMON_TOKEN" ||
+        upper === "GRIP_REMOTE_TOKEN" ||
+        upper.startsWith("GRIP_DAEMON_TLS_") ||
+        upper.startsWith("PI_DAEMON_TLS_") ||
+        SECRET_ENVIRONMENT_SUFFIX.test(upper));
+}
+process.platform === "win32"
+    ? ["PATH", "PATHEXT", "SYSTEMROOT", "TEMP", "TMP"]
+    : ["PATH", "HOME", "LANG", "LC_ALL", "TERM", "TMPDIR"];
+function isMissingPath(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function sanitizeLspStatus(status, configuration) {
+    const { capabilities: _capabilities, ...safe } = status;
+    const secrets = [configuration.token, configuration.tls?.passphrase];
+    const redact = (value) => (value ? redactDaemonText(value, secrets) : undefined);
+    return {
+        ...safe,
+        serverId: redact(safe.serverId),
+        languageIds: safe.languageIds.map((value) => redact(value)),
+        transport: redact(safe.transport),
+        ...(safe.instanceKey ? { instanceKey: redact(safe.instanceKey) } : {}),
+        ...(safe.workspaceRoot ? { workspaceRoot: redact(safe.workspaceRoot) } : {}),
+        ...(safe.rootUri ? { rootUri: redact(safe.rootUri) } : {}),
+        ...(safe.endpoint ? { endpoint: redact(safe.endpoint) } : {}),
+        ...(safe.lastError ? { lastError: redact(safe.lastError) } : {}),
+        ...(safe.lastRequestError ? { lastRequestError: redact(safe.lastRequestError) } : {}),
+        ...(safe.stderr ? { stderr: redact(safe.stderr) } : {}),
+        ...(safe.synchronizationError ? { synchronizationError: redact(safe.synchronizationError) } : {}),
+    };
+}
+function portableToolResult(result) {
+    const clone = JSON.parse(JSON.stringify(result));
+    const details = clone.details;
+    if (!details || typeof details !== "object" || !("fullOutputPath" in details))
+        return clone;
+    const fullOutputPath = details.fullOutputPath;
+    if (typeof fullOutputPath !== "string")
+        return clone;
+    delete details.fullOutputPath;
+    for (const content of clone.content) {
+        if (content.type === "text") {
+            content.text = content.text.replaceAll(fullOutputPath, "[remote full output is not transferable]");
+        }
+    }
+    return clone;
+}
+function operationKind(name) {
+    if (name.startsWith("lsp_"))
+        return "service";
+    switch (name) {
+        case "read":
+        case "grep":
+        case "find":
+        case "ls":
+            return "read";
+        case "edit":
+        case "write":
+            return "mutation";
+        case "bash":
+            return "process";
+    }
+    throw new Error(`Unknown daemon tool: ${name}`);
+}
+function runCommand(command, args, environment, maxBufferedBytes) {
+    return new Promise((resolvePromise, reject) => {
+        const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"], windowsHide: true, env: environment });
+        const stdout = [];
+        const stderr = [];
+        let bufferedBytes = 0;
+        let settled = false;
+        const append = (target, chunk) => {
+            if (settled)
+                return;
+            bufferedBytes += chunk.byteLength;
+            if (bufferedBytes > maxBufferedBytes) {
+                settled = true;
+                child.kill();
+                reject(new Error(`${command} output exceeded the daemon buffered-output limit`));
+                return;
+            }
+            target.push(Buffer.from(chunk));
+        };
+        child.stdout.on("data", (chunk) => append(stdout, chunk));
+        child.stderr.on("data", (chunk) => append(stderr, chunk));
+        child.once("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(error);
+        });
+        child.once("close", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            if (code === 0 || (command === "rg" && code === 1)) {
+                resolvePromise(Buffer.concat(stdout));
+                return;
+            }
+            reject(new Error(Buffer.concat(stderr).toString("utf8").trim() || `${command} exited with code ${code}`));
+        });
+    });
+}
+function isUnknownRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function nestedText(record, key) {
+    const nested = record?.[key];
+    return isUnknownRecord(nested) && typeof nested.text === "string" ? nested.text : undefined;
+}
+function parseDaemonGrepMatch(line) {
+    if (!line)
+        return undefined;
+    let event;
+    try {
+        event = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    const eventRecord = isUnknownRecord(event) ? event : undefined;
+    if (eventRecord?.type !== "match")
+        return undefined;
+    const data = isUnknownRecord(eventRecord.data) ? eventRecord.data : undefined;
+    const filePath = nestedText(data, "path");
+    const lineNumber = data?.line_number;
+    if (!filePath || typeof lineNumber !== "number")
+        return undefined;
+    const lineText = nestedText(data, "lines");
+    return { filePath, lineNumber, ...(lineText === undefined ? {} : { lineText }) };
+}
+export class ConfinedDaemonToolOperations {
+    cwd;
+    local;
+    allowedRoots;
+    allowProcessExec;
+    environment;
+    maxBufferedOutputBytes;
+    constructor(configuration) {
+        this.cwd = configuration.workspaceRoot;
+        this.local = new LocalToolOperations(this.cwd);
+        this.allowedRoots = Object.freeze([
+            this.cwd,
+            ...(configuration.temporaryRoot ? [configuration.temporaryRoot] : []),
+        ]);
+        this.allowProcessExec = configuration.allowProcessExec;
+        this.maxBufferedOutputBytes = configuration.maxBufferedOutputBytes;
+        const localeNames = Object.keys(process.env).filter((name) => /^LC_/iu.test(name));
+        const names = new Set([...BASELINE_ENVIRONMENT, ...localeNames, ...configuration.forwardedEnvironment]);
+        this.environment = {};
+        for (const name of names) {
+            if (isSecretEnvironmentName(name))
+                continue;
+            const value = process.env[name];
+            if (value !== undefined)
+                this.environment[name] = value;
+        }
+    }
+    createChildEnvironment(extra = {}) {
+        const environment = {};
+        for (const [name, value] of Object.entries(this.environment)) {
+            if (value !== undefined)
+                environment[name] = value;
+        }
+        Object.assign(environment, extra);
+        for (const name of Object.keys(environment)) {
+            if (isSecretEnvironmentName(name))
+                delete environment[name];
+        }
+        return environment;
+    }
+    isWithinAllowedRoot(candidate, root) {
+        const pathRelative = relative(root, candidate);
+        return pathRelative !== ".." && !pathRelative.startsWith(`..${sep}`) && !isAbsolute(pathRelative);
+    }
+    lexicalPath(path) {
+        const candidate = resolve(this.cwd, path);
+        if (!this.allowedRoots.some((root) => this.isWithinAllowedRoot(candidate, root))) {
+            throw new Error(`Path escapes the daemon workspace and allowed temporary root: ${path}`);
+        }
+        return candidate;
+    }
+    async existingPath(path) {
+        const candidate = this.lexicalPath(path);
+        const canonical = await realpath(candidate);
+        return this.lexicalPath(canonical);
+    }
+    async existingWritablePath(candidate, path) {
+        try {
+            const stat = await lstat(candidate);
+            if (stat.isSymbolicLink()) {
+                try {
+                    this.lexicalPath(await realpath(candidate));
+                }
+                catch (error) {
+                    if (isMissingPath(error))
+                        throw new Error(`Writable path uses a broken symbolic link: ${path}`);
+                    throw error;
+                }
+                throw new Error(`Writable path uses a symbolic link: ${path}`);
+            }
+            const canonical = await realpath(candidate);
+            this.lexicalPath(canonical);
+            return this.lexicalPath(canonical);
+        }
+        catch (error) {
+            if (isMissingPath(error))
+                return undefined;
+            throw error;
+        }
+    }
+    async ensureConfinedWritableParent(candidate, path) {
+        let parent = resolve(candidate, "..");
+        while (true) {
+            try {
+                const parentStat = await lstat(parent);
+                if (parentStat.isSymbolicLink()) {
+                    this.lexicalPath(await realpath(parent));
+                    throw new Error(`Writable parent uses a symbolic link: ${path}`);
+                }
+                const canonicalParent = await realpath(parent);
+                this.lexicalPath(canonicalParent);
+                return;
+            }
+            catch (error) {
+                if (!isMissingPath(error))
+                    throw error;
+                const next = resolve(parent, "..");
+                if (next === parent)
+                    throw new Error(`No confined parent exists for path: ${path}`);
+                parent = next;
+            }
+        }
+    }
+    async writablePath(path) {
+        const candidate = this.lexicalPath(path);
+        const existing = await this.existingWritablePath(candidate, path);
+        if (existing)
+            return existing;
+        await this.ensureConfinedWritableParent(candidate, path);
+        return candidate;
+    }
+    async atomicWriteFile(path, content) {
+        const target = await this.writablePath(path);
+        const parent = resolve(target, "..");
+        const temporary = resolve(parent, `.grip-remote-write-${process.pid}-${randomUUID()}-${basename(target)}.tmp`);
+        this.lexicalPath(temporary);
+        let wroteTemporary = false;
+        try {
+            const handle = await open(temporary, "wx", 0o600);
+            try {
+                await handle.writeFile(content, typeof content === "string" ? "utf8" : undefined);
+            }
+            finally {
+                await handle.close();
+            }
+            wroteTemporary = true;
+            this.lexicalPath(await realpath(temporary));
+            try {
+                if ((await lstat(target)).isSymbolicLink())
+                    throw new Error(`Writable path uses a symbolic link: ${path}`);
+            }
+            catch (error) {
+                if (!isMissingPath(error))
+                    throw error;
+            }
+            await rename(temporary, target);
+            wroteTemporary = false;
+            this.lexicalPath(await realpath(target));
+        }
+        finally {
+            if (wroteTemporary)
+                await rm(temporary, { force: true });
+        }
+    }
+    async exec(command, options) {
+        if (!this.allowProcessExec)
+            throw new Error("Process execution is disabled by daemon policy");
+        const cwd = await this.existingPath(options.cwd ?? this.cwd);
+        const environment = { ...this.environment };
+        for (const name of GRIP_SESSION_ENVIRONMENT_NAMES) {
+            const value = options.env?.[name];
+            if (value !== undefined)
+                environment[name] = value;
+        }
+        return this.local.exec(command, { ...options, cwd, env: environment });
+    }
+    async access(path, mode) {
+        await this.local.access(await this.existingPath(path), mode);
+    }
+    async readFile(path) {
+        return this.local.readFile(await this.existingPath(path));
+    }
+    async writeFile(path, content) {
+        await this.atomicWriteFile(path, content);
+    }
+    async mkdir(path, options) {
+        await fsMkdir(await this.writablePath(path), options);
+    }
+    async stat(path) {
+        return this.local.stat(await this.existingPath(path));
+    }
+    async readdir(path) {
+        return this.local.readdir(await this.existingPath(path));
+    }
+    async glob(pattern, cwd, options) {
+        const searchRoot = await this.existingPath(cwd);
+        const args = ["--glob", "--color=never", "--hidden", "--no-require-git", "--max-results", String(options.limit)];
+        for (const ignored of options.ignore)
+            args.push("--exclude", ignored);
+        let effectivePattern = pattern;
+        if (pattern.includes("/")) {
+            args.push("--full-path");
+            if (!pattern.startsWith("/") && !pattern.startsWith("**/") && pattern !== "**")
+                effectivePattern = `**/${pattern}`;
+        }
+        args.push("--", effectivePattern, searchRoot);
+        const output = await runCommand("fd", args, this.environment, this.maxBufferedOutputBytes);
+        const results = [];
+        for (const entry of output.toString("utf8").split("\n")) {
+            if (!entry)
+                continue;
+            try {
+                results.push(await this.existingPath(entry));
+            }
+            catch {
+                // Symlinks escaping the workspace are deliberately omitted.
+            }
+        }
+        return results;
+    }
+    async grep(options) {
+        const searchPath = await this.existingPath(options.path);
+        const isDirectory = (await this.local.stat(searchPath)).isDirectory();
+        const args = ["--json", "--line-number", "--color=never", "--hidden"];
+        if (options.ignoreCase)
+            args.push("--ignore-case");
+        if (options.literal)
+            args.push("--fixed-strings");
+        if (options.glob)
+            args.push("--glob", options.glob);
+        args.push("--", options.pattern, searchPath);
+        const output = await runCommand("rg", args, this.environment, this.maxBufferedOutputBytes);
+        const matches = [];
+        for (const line of output.toString("utf8").split("\n")) {
+            if (matches.length >= options.limit)
+                continue;
+            const match = parseDaemonGrepMatch(line);
+            if (!match)
+                continue;
+            try {
+                await this.existingPath(match.filePath);
+            }
+            catch {
+                continue;
+            }
+            matches.push(match);
+        }
+        return { isDirectory, matches };
+    }
+    async detectImageMimeType(path) {
+        return this.local.detectImageMimeType(await this.existingPath(path));
+    }
+    getBackendInfo() {
+        return { type: "local", cwd: this.cwd };
+    }
+}
+function requestError(code, message, state) {
+    return new RemoteWorkspaceRequestError({ code, message, executionState: state, retryable: false });
+}
+function withDaemonWorkspace(result, workspace) {
+    return { ...result, workspace };
+}
+async function synchronizeDaemonToolFile(toolName, invocationArguments, runtime) {
+    if (!runtime.lspRuntime)
+        return;
+    const args = invocationArguments;
+    if (typeof args.path !== "string")
+        return;
+    try {
+        if (toolName === "read") {
+            await runtime.lspRuntime.fileSync.handleFileRead(args.path, runtime.operations);
+        }
+        else if (toolName === "write" || toolName === "edit") {
+            await runtime.lspRuntime.fileSync.handleFileWrite(args.path, runtime.operations);
+        }
+    }
+    catch {
+        // Synchronization remains best-effort, matching local AgentSession behavior.
+    }
+}
+function marksToolSideEffect(kind, toolName, sharedMode) {
+    return kind !== "read" && !(sharedMode && (toolName === "edit" || toolName === "write"));
+}
+async function invokeDaemonTool(request, params, context, runtime) {
+    const toolName = params.toolName;
+    const kind = operationKind(toolName);
+    if (marksToolSideEffect(kind, toolName, runtime.sharedMode))
+        context.markSideEffectStarted();
+    let updateQueue = Promise.resolve();
+    try {
+        const result = await runtime.host.executePrepared(toolName, {
+            toolCallId: request.id,
+            arguments: params.arguments,
+            signal: context.signal,
+            executionOptions: params.executionOptions,
+            onUpdate: (update) => {
+                updateQueue = updateQueue.then(() => context.sendUpdate(portableToolResult(update)));
+            },
+        });
+        await updateQueue;
+        await synchronizeDaemonToolFile(toolName, params.arguments, runtime);
+        if (kind !== "read")
+            context.markCommitted();
+        return portableToolResult(result);
+    }
+    catch (error) {
+        await updateQueue.catch(() => undefined);
+        if (context.signal.aborted) {
+            throw requestError("cancelled", "Remote workspace tool invocation was cancelled", kind === "read" ? "not_started" : "indeterminate");
+        }
+        if (error instanceof RemoteWorkspaceRequestError)
+            throw error;
+        throw new RemoteWorkspaceRequestError({
+            code: "internal_error",
+            message: error instanceof Error ? error.message.slice(0, 4096) : "Workspace tool failed",
+            executionState: kind === "read" ? "not_started" : "indeterminate",
+            retryable: false,
+        });
+    }
+}
+async function executeDaemonWorkspaceProcess(params, context, runtime) {
+    context.markSideEffectStarted();
+    let updateQueue = Promise.resolve();
+    let pendingOutputBytes = 0;
+    let outputLimitExceeded = false;
+    const outputController = new AbortController();
+    const signal = AbortSignal.any([context.signal, outputController.signal]);
+    let result;
+    try {
+        result = await runtime.operations.exec(params.command, {
+            cwd: params.cwd,
+            signal,
+            onData: (data) => {
+                if (outputLimitExceeded)
+                    return;
+                const chunk = Buffer.from(data);
+                pendingOutputBytes += chunk.byteLength;
+                if (pendingOutputBytes > runtime.configuration.maxBufferedOutputBytes) {
+                    outputLimitExceeded = true;
+                    outputController.abort();
+                    return;
+                }
+                updateQueue = updateQueue
+                    .then(() => context.sendUpdate({ dataBase64: chunk.toString("base64") }))
+                    .finally(() => {
+                    pendingOutputBytes -= chunk.byteLength;
+                });
+                // The process may run after an update fails; observe rejection until the final await.
+                void updateQueue.catch(() => undefined);
+            },
+        });
+    }
+    catch (error) {
+        if (outputLimitExceeded)
+            throw new Error("Process output exceeded the daemon buffered-output limit");
+        throw error;
+    }
+    await updateQueue;
+    context.markCommitted();
+    return result;
+}
+async function readDaemonResource(params, runtime) {
+    const path = params.path;
+    const resourcePath = path === "SANDBOX.md"
+        ? runtime.configuration.sandboxInstructionsPath
+        : path === "AGENTS.md"
+            ? runtime.configuration.userAgentsPath
+            : undefined;
+    if (!resourcePath) {
+        throw new RemoteWorkspaceRequestError({
+            code: "not_available",
+            message: "Requested daemon resource is not available",
+            executionState: "not_started",
+            retryable: false,
+        });
+    }
+    return withDaemonWorkspace({ contentBase64: (await readFile(resourcePath)).toString("base64") }, runtime.workspace);
+}
+function getDaemonLspStatus(runtime) {
+    if (!runtime.lspRuntime) {
+        throw new RemoteWorkspaceRequestError({
+            code: "not_available",
+            message: "Daemon LSP is not configured",
+            executionState: "not_started",
+            retryable: false,
+        });
+    }
+    return {
+        enabled: true,
+        servers: runtime.lspRuntime.manager.getStatus().map((status) => sanitizeLspStatus(status, runtime.configuration)),
+    };
+}
+async function statDaemonWorkspace(path, runtime) {
+    try {
+        const value = await runtime.operations.stat(path);
+        return withDaemonWorkspace({ kind: value.isDirectory() ? "directory" : value.isFile() ? "file" : "other" }, runtime.workspace);
+    }
+    catch (error) {
+        if (!runtime.sharedMode || !isMissingPath(error))
+            throw error;
+        return withDaemonWorkspace({ kind: "absent" }, runtime.workspace);
+    }
+}
+async function dispatchDaemonWorkspaceRequest(request, context, runtime) {
+    const params = request.params;
+    switch (request.method) {
+        case "tool.invoke":
+            return invokeDaemonTool(request, params, context, runtime);
+        case "workspace.access":
+            await runtime.operations.access(params.path, params.mode);
+            return {};
+        case "workspace.read":
+            return withDaemonWorkspace({ contentBase64: (await runtime.operations.readFile(params.path)).toString("base64") }, runtime.workspace);
+        case "workspace.write":
+            if (!runtime.sharedMode)
+                context.markSideEffectStarted();
+            await withFileMutationQueue(resolve(runtime.configuration.workspaceRoot, params.path), () => runtime.operations.writeFile(params.path, Buffer.from(params.contentBase64, "base64")));
+            context.markCommitted();
+            return {};
+        case "workspace.mkdir":
+            if (!runtime.sharedMode)
+                context.markSideEffectStarted();
+            await withFileMutationQueue(resolve(runtime.configuration.workspaceRoot, params.path), () => {
+                if (runtime.sharedMode) {
+                    if (context.signal.aborted)
+                        throw requestError("cancelled", "Shared directory creation was cancelled before starting", "not_started");
+                    context.markSideEffectStarted();
+                }
+                return runtime.operations.mkdir(params.path, { recursive: params.recursive === true });
+            });
+            context.markCommitted();
+            return {};
+        case "workspace.stat":
+            return statDaemonWorkspace(params.path, runtime);
+        case "workspace.readdir":
+            return withDaemonWorkspace({ entries: await runtime.operations.readdir(params.path) }, runtime.workspace);
+        case "workspace.glob":
+            return withDaemonWorkspace({
+                matches: await runtime.operations.glob(params.pattern, params.cwd, {
+                    ignore: params.ignore,
+                    limit: params.limit,
+                }),
+            }, runtime.workspace);
+        case "workspace.grep": {
+            const result = await runtime.operations.grep(params);
+            return withDaemonWorkspace(result, runtime.workspace);
+        }
+        case "workspace.detect_image_mime":
+            return withDaemonWorkspace({ mimeType: (await runtime.operations.detectImageMimeType(params.path)) ?? null }, runtime.workspace);
+        case "workspace.exec":
+            return executeDaemonWorkspaceProcess(params, context, runtime);
+        case "resource.read":
+            return readDaemonResource(params, runtime);
+        case "lsp.status":
+            return getDaemonLspStatus(runtime);
+        default:
+            throw new RemoteWorkspaceRequestError({
+                code: "method_not_supported",
+                message: `Workspace operation is not implemented: ${request.method}`,
+                executionState: "not_started",
+                retryable: false,
+            });
+    }
+}
+export function createDaemonWorkspaceRuntime(configuration) {
+    const operations = new ConfinedDaemonToolOperations(configuration);
+    const toolNames = ["read", "edit", "write", "grep", "find", "ls"];
+    if (configuration.allowProcessExec)
+        toolNames.splice(1, 0, "bash");
+    const lspConfiguration = loadDaemonLspConfiguration(configuration);
+    const lspRuntime = lspConfiguration.enabled
+        ? createLspRuntimeState(configuration.workspaceRoot, {
+            configuration: lspConfiguration,
+            getToolBackendInfo: () => operations.getBackendInfo(),
+            getToolOperations: () => operations,
+            resolveConnectionFactory: (transport) => transport.type === "spawn"
+                ? createManagedStdioConnectionFactory({
+                    ...transport,
+                    env: operations.createChildEnvironment(transport.env),
+                    inheritEnvironment: false,
+                })
+                : resolveLspConnectionFactory(transport),
+        })
+        : undefined;
+    const host = new WorkspaceToolHost({
+        cwd: configuration.workspaceRoot,
+        operations,
+        toolNames,
+        additionalDefinitions: lspRuntime
+            ? createLspToolDefinitions(() => lspRuntime, () => operations)
+            : undefined,
+        disposeTimeoutMs: Math.min(configuration.shutdownTimeoutMs, 60_000),
+    });
+    const catalog = {
+        generation: 1,
+        tools: host.getCatalog().map((entry) => ({
+            name: entry.name,
+            executionMode: operationKind(entry.name),
+            parameterSchema: structuredClone(entry.parameters),
+            schemaHash: hashRemoteWorkspaceJson(entry.parameters),
+            featureFlags: [],
+        })),
+        operations: [
+            ...PRIMITIVE_OPERATIONS.filter((method) => method !== "workspace.exec" || configuration.allowProcessExec),
+            ...(configuration.sandboxInstructionsPath || configuration.userAgentsPath ? ["resource.read"] : []),
+            ...(lspRuntime ? ["lsp.status"] : []),
+        ],
+    };
+    const capabilities = [
+        "catalog_refresh",
+        "primitive_operations",
+        "tool_updates",
+        ...(lspRuntime ? ["lsp_status"] : []),
+    ];
+    let activeRequests = 0;
+    return {
+        operations,
+        host,
+        lspRuntime,
+        catalog,
+        capabilities,
+        createHandler(workspace, sharedMode = false) {
+            const requestRuntime = {
+                configuration,
+                operations,
+                host,
+                lspRuntime,
+                workspace,
+                sharedMode,
+            };
+            return {
+                validateToolArguments: (toolName, value) => host.validatePreparedArguments(toolName, value),
+                async handleRequest(request, context) {
+                    if (activeRequests >= configuration.maxGlobalRequests) {
+                        throw new RemoteWorkspaceRequestError({
+                            code: "limit_exceeded",
+                            message: "Daemon global active request limit reached",
+                            executionState: "not_started",
+                            retryable: true,
+                        });
+                    }
+                    activeRequests++;
+                    try {
+                        return await dispatchDaemonWorkspaceRequest(request, context, requestRuntime);
+                    }
+                    finally {
+                        activeRequests--;
+                    }
+                },
+            };
+        },
+        retire: async () => {
+            await host.waitForIdle(configuration.shutdownTimeoutMs);
+            await lspRuntime?.manager.shutdownAll();
+            await host.dispose();
+        },
+        dispose: async () => {
+            await Promise.all([lspRuntime?.manager.shutdownAll(), host.dispose()]);
+        },
+    };
+}
+//# sourceMappingURL=workspace-runtime.js.map