@lensagent/core 0.1.1 → 0.1.2

package/dist/adapters/executor.js

@@ -1,6 +1,6 @@
 import { randomBytes } from 'node:crypto';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { dirname, isAbsolute, resolve } from 'node:path';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import * as grpc from '@grpc/grpc-js';
 import * as protoLoader from '@grpc/proto-loader';
@@ -30,18 +30,21 @@ export class ExecutorCallError extends Error {
 const executorProtoPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../proto/executor.proto');
 // Set explicitly instead of inheriting @grpc/grpc-js's 4 MiB receive default. Keep in step with the
 // same constant in lens-remote-executor's src/main.ts: the Executor's server-side receive limit is
-// what actually bounds a write_file request, so both sides have to agree.
+// what actually bounds a file-edit request, so both sides have to agree.
 const maxMessageBytes = 16 * 1024 * 1024;
 // Rejected in Core with a usable message rather than letting the transport fail with
 // RESOURCE_EXHAUSTED. Below maxMessageBytes so the rest of the request always fits.
 const contentLimitBytes = 8 * 1024 * 1024;
 export class ExecutorClient {
     config;
+    endpoint;
     id = 'executor';
     #client;
     #metadata = new grpc.Metadata();
-    constructor(client, config, identity) {
+    #sharedPaths = new Set();
+    constructor(client, config, endpoint, identity) {
         this.config = config;
+        this.endpoint = endpoint;
         this.#client = client;
         if (identity !== undefined) {
             this.#metadata.set('x-lens-client-kind', 'native');
@@ -49,14 +52,25 @@ export class ExecutorClient {
             this.#metadata.set('x-lens-hardware-id', identity.hardwareId);
         }
     }
-    static async create(root, runtime) {
-        const config = runtime.current.config.executor;
+    static async create(root, runtime, endpoint = runtime.current.config.executor) {
+        const config = endpoint;
         const packageDefinition = protoLoader.loadSync(executorProtoPath, { keepCase: true, longs: Number, defaults: true, oneofs: true });
         const loaded = grpc.loadPackageDefinition(packageDefinition);
         const credentials = await channelCredentials(root, config);
         const clientIdentity = config.identityPath === undefined ? undefined : await loadIdentity(resolve(root, config.identityPath));
         const options = { 'grpc.max_receive_message_length': maxMessageBytes, 'grpc.max_send_message_length': maxMessageBytes };
-        return new ExecutorClient(new loaded.lens.executor.v1.Executor(config.address, credentials, options), runtime, clientIdentity);
+        const adapter = new ExecutorClient(new loaded.lens.executor.v1.Executor(config.address, credentials, options), runtime, config, clientIdentity);
+        if (config.credentialPath !== undefined) {
+            if (config.tls?.enabled !== true && !/^(localhost|127\.0\.0\.1|\[::1\]):\d+$/u.test(config.address)) {
+                adapter.close();
+                throw new Error('Core Executor service credentials require TLS outside loopback.');
+            }
+            const token = (await readFile(resolve(root, config.credentialPath), 'utf8')).trim();
+            if (!/^[A-Za-z0-9_-]{43}$/u.test(token))
+                throw new Error('Invalid Core Executor service credential.');
+            adapter.#metadata.set('x-lens-core-credential', token);
+        }
+        return adapter;
     }
     close() {
         this.#client.close();
@@ -64,6 +78,23 @@ export class ExecutorClient {
     health(signal) {
         return this.call('health', {}, 5000, signal);
     }
+    async taskAudit(projectId, taskId, limit, cursor) {
+        const response = object(await this.call('queryTaskAudit', { project_id: projectId, task_id: taskId, limit, cursor: cursor ?? '' }, 30000));
+        if (!Array.isArray(response.events_json) || response.events_json.some(value => typeof value !== 'string')) {
+            fail('EXECUTOR_AUDIT_INVALID', 502, 'Executor returned an invalid audit page.');
+        }
+        let items;
+        try {
+            items = response.events_json.map((value) => jsonValue(JSON.parse(value)));
+        }
+        catch {
+            fail('EXECUTOR_AUDIT_INVALID', 502, 'Executor returned invalid audit events.');
+        }
+        return { items, next_cursor: typeof response.next_cursor === 'string' && response.next_cursor !== '' ? response.next_cursor : null,
+            coverage: { model_transport: 'not_queried', executor_access: 'executor_observed_requesting_declared_client_only',
+                exports: 'not_recorded', employee_identity: 'not_authenticated', completeness: 'partial', incomplete_tail: response.incomplete_tail === true },
+            integrity: string(response.integrity), ordering: string(response.ordering), scope: string(response.scope) };
+    }
     browse(path, signal) {
         return this.call('listAllowedParent', { path }, 30000, signal);
     }
@@ -73,8 +104,25 @@ export class ExecutorClient {
     open(workspacePaths, path, signal) {
         return this.call('openInFileManager', { workspace_paths: workspacePaths, path, full_access: false }, 30000, signal);
     }
-    validatePaths(paths, signal, createIfMissing = false) {
-        return this.call('validateWorkspacePaths', { workspace_paths: paths, create_if_missing: createIfMissing }, 30000, signal);
+    async validatePaths(paths, signal, createIfMissing = false) {
+        const response = await this.call('validateWorkspacePaths', { workspace_paths: paths, create_if_missing: createIfMissing }, 30000, signal);
+        const resolved = object(response).resolved_paths;
+        if (Array.isArray(resolved))
+            await this.verifySharedPaths(resolved.filter((path) => typeof path === 'string'), signal);
+        return response;
+    }
+    sharedWorkspace(path) { return this.#sharedPaths.has(path); }
+    async verifySharedPaths(paths, signal) {
+        if (this.endpoint.sharedFilesystem !== true)
+            return;
+        for (const root of paths) {
+            this.#sharedPaths.delete(root);
+            await verifySharedWorkspace(root, async (path, expected) => {
+                const response = object(await this.call('readFile', { workspace_paths: [root], path, full_access: false, max_bytes: 1024, max_lines: 2 }, 5000, signal));
+                return response.content === expected;
+            });
+            this.#sharedPaths.add(root);
+        }
     }
     // Drops the Executor's file history for Calls that Core has physically deleted, so revertable
     // state does not outlive the Call it belongs to. Called after the purge transaction commits --
@@ -90,24 +138,50 @@ export class ExecutorClient {
     }
     async execute(invocation) {
         const input = object(invocation.arguments);
+        const audit = new grpc.Metadata();
+        audit.set('x-lens-call-id', invocation.callId);
+        audit.set('x-lens-project-id', invocation.projectId);
+        audit.set('x-lens-workspace-id', invocation.workspaceId);
+        if (invocation.agentId !== null)
+            audit.set('x-lens-agent-id', invocation.agentId);
+        if (invocation.taskId !== undefined)
+            audit.set('x-lens-task-id', invocation.taskId);
+        const call = (method, request, timeout, signal) => this.call(method, request, timeout, signal, audit);
         const common = { workspace_paths: invocation.workspacePaths, full_access: invocation.fullAccess === true };
         const worker = this.config.current.config.worker;
-        // write_file/edit_file carry the Workspace and Call identity so the Executor can record the
+        // edit_file/patch_file carry the Workspace and Call identity so the Executor can record the
         // change in its own file history for a later revert_call. Core never sees the file bytes or
         // their object ids -- see docs/architecture/harness-level3/09-file-snapshot-storage-decision.md.
         const change = { workspace_id: invocation.workspaceId, call_id: invocation.callId };
         if (invocation.capabilityId === 'read_file')
-            return result(await this.call('readFile', { ...common, path: string(input.path) }, 30000, invocation.signal));
-        if (invocation.capabilityId === 'write_file') {
-            return result(await this.call('writeFile', { ...common, ...change, path: string(input.path), content: bounded(text(input.content), 'content') }, 30000, invocation.signal));
+            return result(await call('readFile', {
+                ...common, path: string(input.path), start_line: optionalNumber(input.start_line) ?? 1,
+                max_lines: optionalNumber(input.max_lines) ?? 2000, max_bytes: optionalNumber(input.max_bytes) ?? 65536,
+                offset: optionalNumber(input.offset) ?? 0
+            }, 30000, invocation.signal));
+        if (invocation.capabilityId === 'view_image') {
+            const image = object(await call('viewImage', { ...common, path: string(input.path) }, 30000, invocation.signal));
+            const bytes = Buffer.from(string(image.data), 'base64');
+            return { capture: 'complete', content: { path: string(input.path), media_type: string(image.media_type), size_bytes: bytes.length, ...(image.evidence == null ? {} : { evidence: jsonValue(image.evidence) }) },
+                artifacts: [{ name: string(input.path).split(/[\\/]/).pop() ?? 'image', mediaType: string(image.media_type), bytes }] };
         }
         if (invocation.capabilityId === 'edit_file') {
-            return result(await this.call('editFile', { ...common, ...change, path: string(input.path), old_string: string(input.old_string), new_string: bounded(text(input.new_string), 'new_string'), replace_all: input.replace_all === true }, 30000, invocation.signal));
+            const edits = input.edits === undefined ? [] : editEntries(input.edits);
+            const content = input.content === undefined ? undefined : bounded(text(input.content), 'content');
+            const size = edits.reduce((bytes, edit) => bytes + Buffer.byteLength(edit.old_string) + Buffer.byteLength(edit.new_string), 0);
+            if (size > contentLimitBytes)
+                fail('FILE_TOO_LARGE', 413, 'Total edit input exceeds 8 MiB.');
+            return this.#fileChange('editFile', { ...common, ...change, path: string(input.path), operation: string(input.operation),
+                ...(content === undefined ? {} : { content }), edits }, invocation.signal, audit);
         }
+        if (invocation.capabilityId === 'patch_file')
+            return this.#fileChange('patchFile', {
+                ...common, ...change, path: string(input.path), patch: bounded(string(input.patch), 'patch')
+            }, invocation.signal, audit);
         if (invocation.capabilityId === 'glob')
-            return result(await this.call('glob', { ...common, pattern: string(input.pattern), path: optionalString(input.path) ?? '.', include_hidden: input.include_hidden === true, max_results: optionalNumber(input.max_results) ?? 1000 }, 30000, invocation.signal));
+            return result(await call('glob', { ...common, pattern: string(input.pattern), path: optionalString(input.path) ?? '.', include_hidden: input.include_hidden === true, max_results: optionalNumber(input.max_results) ?? 1000 }, 30000, invocation.signal));
         if (invocation.capabilityId === 'grep')
-            return result(await this.call('grep', {
+            return result(await call('grep', {
                 ...common,
                 pattern: string(input.pattern),
                 path: optionalString(input.path) ?? '.',
@@ -120,30 +194,57 @@ export class ExecutorClient {
             }, 30000, invocation.signal));
         if (invocation.capabilityId === 'terminal_command_run') {
             const timeout = optionalNumber(input.timeout_ms) ?? worker.timeoutMs;
-            return processResult(await this.call('runCommand', { ...common, command: string(input.command), args: strings(input.args), cwd: optionalString(input.cwd) ?? '.', env: stringRecord(input.env), timeout_ms: timeout, output_limit_bytes: optionalNumber(input.output_limit_bytes) ?? worker.outputLimitBytes }, timeout + 5000, invocation.signal));
+            return processResult(await call('runCommand', { ...common, command: string(input.command), args: strings(input.args), cwd: optionalString(input.cwd) ?? '.', env: stringRecord(input.env), timeout_ms: timeout, output_limit_bytes: optionalNumber(input.output_limit_bytes) ?? worker.outputLimitBytes }, timeout + 5000, invocation.signal));
         }
-        if (invocation.capabilityId === 'git_run') {
-            const timeout = optionalNumber(input.timeout_ms) ?? worker.timeoutMs;
-            return processResult(await this.call('gitRun', { ...common, args: strings(input.args), cwd: optionalString(input.cwd) ?? '.', timeout_ms: timeout, output_limit_bytes: optionalNumber(input.output_limit_bytes) ?? worker.outputLimitBytes }, timeout + 5000, invocation.signal));
-        }
-        if (invocation.capabilityId === 'internet_search')
-            return result(await this.call('internetSearch', { query: string(input.query), max_results: optionalNumber(input.max_results) ?? 5 }, 30000, invocation.signal));
-        if (invocation.capabilityId === 'open_in_file_manager')
-            return result(await this.call('openInFileManager', { ...common, path: optionalString(input.path) ?? '.' }, 30000, invocation.signal));
         fail('CAPABILITY_NOT_FOUND', 404, 'The Executor Capability does not exist.');
     }
-    call(method, request, timeoutMs, signal) {
+    async #fileChange(method, request, signal, audit) {
+        try {
+            return { content: { structured_content: await this.call(method, request, 30000, signal, audit) }, capture: 'complete' };
+        }
+        catch (error) {
+            if (!(error instanceof ExecutorCallError))
+                throw error;
+            let details;
+            try {
+                details = JSON.parse(error.message);
+            }
+            catch {
+                throw error;
+            }
+            if (typeof details !== 'object' || details === null || !('code' in details) || typeof details.code !== 'string'
+                || !/^(?:FILE|EDIT|PATCH)_[A-Z_]+$/u.test(details.code))
+                throw error;
+            return { outcome: 'failed', errorCode: details.code, capture: 'complete', content: { error: jsonValue(details) } };
+        }
+    }
+    call(method, request, timeoutMs, signal, audit) {
+        const metadata = this.#metadata.clone();
+        if (audit !== undefined)
+            metadata.merge(audit);
         const invoke = this.#client[method];
         if (invoke === undefined)
             fail('EXECUTOR_PROTOCOL_ERROR', 503, `Executor RPC ${method} is unavailable.`);
         return new Promise((resolveResult, reject) => {
-            const call = invoke.call(this.#client, request, this.#metadata, { deadline: Date.now() + timeoutMs }, (error, response) => {
-                if (error !== null)
-                    reject(new ExecutorCallError(error.details || error.message, error.code));
-                else
-                    resolveResult(jsonValue(response));
-            });
-            signal?.addEventListener('abort', () => call.cancel(), { once: true });
+            signal?.throwIfAborted();
+            let call;
+            const abort = () => { call?.cancel(); };
+            signal?.addEventListener('abort', abort, { once: true });
+            try {
+                call = invoke.call(this.#client, request, metadata, { deadline: Date.now() + timeoutMs }, (error, response) => {
+                    signal?.removeEventListener('abort', abort);
+                    if (error !== null)
+                        reject(new ExecutorCallError(error.details || error.message, error.code));
+                    else
+                        resolveResult(jsonValue(response));
+                });
+                if (signal?.aborted === true)
+                    call.cancel();
+            }
+            catch (error) {
+                signal?.removeEventListener('abort', abort);
+                throw error;
+            }
         });
     }
 }
@@ -152,56 +253,80 @@ export function executorCapabilities(adapter) {
         definition,
         adapter,
         manifest: capabilityManifest(definition),
-        claims: (context) => claims(definition.id, object(context.arguments), context.workspacePaths)
+        claims: () => claims(definition.id)
     }));
 }
 const stringSchema = { type: 'string', minLength: 1 };
 const stringArray = { type: 'array', items: { type: 'string' } };
 const environmentSchema = { type: 'object', additionalProperties: { type: 'string' } };
 const positive = { type: 'integer', minimum: 1 };
-const outputLimits = { edit_file: 262144, internet_search: 262144, grep: 2097152, open_in_file_manager: 4096 };
+const fileChangeSchema = {
+    type: 'object', additionalProperties: false,
+    properties: { path: stringSchema, changed: { type: 'boolean' }, units_applied: { type: 'integer', minimum: 0 }, bytes_written: { type: 'integer', minimum: 0 } },
+    required: ['path', 'changed', 'units_applied', 'bytes_written']
+};
+const outputLimits = { edit_file: 262144, patch_file: 262144, grep: 2097152 };
 const defaultAssignments = {
-    read_file: 'all_new_agents', write_file: 'all_new_agents', edit_file: 'all_new_agents', glob: 'all_new_agents', grep: 'all_new_agents', open_in_file_manager: 'none'
+    read_file: 'all_new_agents', view_image: 'all_new_agents', edit_file: 'all_new_agents', patch_file: 'all_new_agents', glob: 'all_new_agents', grep: 'all_new_agents'
 };
 /**
  * The read-only file loop, loaded for every new Agent rather than discovered.
  *
  * Every Executor Capability used to be `deferred`, so a new Agent's loaded set held no way to see the
  * Workspace at all. Deferred loading is meant to keep rarely-used tool schemas out of the prompt, and
- * for `git_run` or `internet_search` that is right -- but an Agent cannot decide whether it needs to
+ * for `terminal_command_run` that is right -- but an Agent cannot decide whether it needs to
  * look at the files before it has looked at the files. Asked "does a PowerShell script run during the
  * VM build", one searched the catalogue for a VM-build capability, found none, and asked the user to
  * describe their setup -- while the answer sat in a Packer template two `glob` calls away. The failure
  * is structural, not a bad guess: discovery only works when the Agent knows what to look for, and the
  * first question about an unfamiliar Workspace is exactly when it does not.
  *
- * Three schemas is the whole cost. Writing, running commands and reaching the network stay deferred:
+ * Four schemas is the whole cost. Writing, running commands and reaching the network stay deferred:
  * those are decisions an Agent makes *after* reading, when it does know what it is looking for.
  */
-const eagerCapabilities = new Set(['read_file', 'glob', 'grep']);
+const eagerCapabilities = new Set(['read_file', 'view_image', 'glob', 'grep']);
 const definitions = [
-    definition('read_file', 'Read file', 'Read UTF-8 file content inside the Workspace.', 'read_only', { path: stringSchema }, ['path']),
-    definition('write_file', 'Write file', 'Write UTF-8 file content inside the Workspace.', 'workspace_write', { path: stringSchema, content: { type: 'string' } }, ['path', 'content']),
-    definition('edit_file', 'Edit file', 'Replace exact text inside a Workspace file.', 'workspace_write', { path: stringSchema, old_string: stringSchema, new_string: { type: 'string' }, replace_all: { type: 'boolean' } }, ['path', 'old_string', 'new_string']),
+    definition('read_file', 'Read file or directory', 'Read a UTF-8 text file or list a directory. Directory names are sorted, include hidden entries, and append / to subdirectories. Defaults to the first 2000 lines or entries, or 64 KiB. Use start_line (1-based), or pass next_offset as UTF-8 byte offset to continue. Do not combine a nonzero offset with start_line > 1. File content preserves line endings. kind identifies file/directory; eof indicates completion. Binary files are rejected.', 'read_only', {
+        path: stringSchema, start_line: { ...positive, maximum: Number.MAX_SAFE_INTEGER },
+        max_lines: { ...positive, maximum: 10000 }, max_bytes: { type: 'integer', minimum: 4, maximum: 262144 },
+        offset: { type: 'integer', minimum: 0, maximum: Number.MAX_SAFE_INTEGER }
+    }, ['path']),
+    definition('view_image', 'View image', 'View a PNG, JPEG, GIF or WebP image inside the Workspace. Returns image content to the model. Maximum file size: 5 MiB.', 'read_only', { path: stringSchema }, ['path']),
+    definition('edit_file', 'Edit file', 'Create a UTF-8 file, rewrite an existing file, or apply ordered literal replacements. create requires a missing target; edit/rewrite require an existing regular UTF-8 file. For create/rewrite provide content and omit edits; for edit provide edits and omit content. Empty content is allowed. Each old_string must match exactly once unless replace_all is true. All edits are validated before one atomic commit. At most 128 edits and 8 MiB of input/file content. Changes are recorded for revert_call.', 'workspace_write', {
+        path: stringSchema, operation: { type: 'string', enum: ['create', 'edit', 'rewrite'] }, content: { type: 'string' },
+        edits: { type: 'array', minItems: 1, maxItems: 128, items: { type: 'object', additionalProperties: false,
+                properties: { old_string: stringSchema, new_string: { type: 'string' }, replace_all: { type: 'boolean', default: false } }, required: ['old_string', 'new_string'] } }
+    }, ['path', 'operation'], fileChangeSchema),
+    definition('patch_file', 'Patch file', 'Apply contextual line-based update hunks to one existing UTF-8 file. Begin each hunk with @@ or @@ followed by an exact unique line anchor. Prefix unchanged lines with a space, additions with +, removals with -. Supply hunks only: path is separate. All hunks refer to the original file, must match uniquely, and cannot overlap. Optional *** End of File requires matching at the end. Pure additions require an empty file and one hunk. Preserve exact whitespace and unchanged line endings. At most 128 hunks and 8 MiB input/file content. Commit once and record for revert_call.', 'workspace_write', { path: stringSchema, patch: stringSchema }, ['path', 'patch'], fileChangeSchema),
     definition('glob', 'Glob files', 'Find Workspace files by wildcard pattern.', 'read_only', { pattern: stringSchema, path: stringSchema, include_hidden: { type: 'boolean' }, max_results: { ...positive, maximum: 10000 } }, ['pattern']),
-    definition('grep', 'Search files', 'Find text or regular expression matches inside Workspace files.', 'read_only', { pattern: stringSchema, path: stringSchema, glob: stringSchema, literal: { type: 'boolean' }, case_sensitive: { type: 'boolean' }, include_hidden: { type: 'boolean' }, max_results: { ...positive, maximum: 10000 }, max_bytes_per_file: { ...positive, maximum: 10485760 } }, ['pattern']),
-    definition('terminal_command_run', 'Run command', 'Run a command without a shell inside the Workspace.', 'full', { command: stringSchema, args: stringArray, cwd: stringSchema, env: environmentSchema, timeout_ms: positive, output_limit_bytes: positive }, ['command']),
-    definition('git_run', 'Run Git', 'Run Git arguments inside the Workspace.', 'full', { args: stringArray, cwd: stringSchema, timeout_ms: positive, output_limit_bytes: positive }, ['args']),
-    definition('internet_search', 'Search internet', 'Search public web pages.', 'external', { query: stringSchema, max_results: { ...positive, maximum: 20 } }, ['query']),
-    definition('open_in_file_manager', 'Open in file manager', 'Open a Workspace path in the operating system file manager.', 'external', { path: stringSchema }, [])
+    definition('grep', 'Search files', 'Find text or regular expression matches inside Workspace files. Results include 1-based line numbers. truncated means additional matches exist or a file exceeded max_bytes_per_file; narrow path/glob or raise the limits to inspect more.', 'read_only', { pattern: stringSchema, path: stringSchema, glob: stringSchema, literal: { type: 'boolean' }, case_sensitive: { type: 'boolean' }, include_hidden: { type: 'boolean' }, max_results: { ...positive, maximum: 10000 }, max_bytes_per_file: { type: 'integer', minimum: 4, maximum: 10485760 } }, ['pattern']),
+    definition('terminal_command_run', 'Run command', 'Run a command without a shell inside the Workspace.', 'full', { command: stringSchema, args: stringArray, cwd: stringSchema, env: environmentSchema, timeout_ms: positive, output_limit_bytes: positive }, ['command'])
 ];
-function claims(capabilityId, input, paths) {
-    if (capabilityId === 'internet_search')
-        return [{ resource: 'network', mode: 'read' }];
-    const path = optionalString(input.path) ?? optionalString(input.cwd) ?? '.';
-    return [{ resource: pathResource(path, paths), mode: ['write_file', 'edit_file', 'terminal_command_run', 'git_run'].includes(capabilityId) ? 'write' : 'read' }];
+function claims(capabilityId) {
+    // Core cannot canonicalize a remote filesystem. Cover all aliases and command
+    // side effects in this scheduler's execution domain; concurrent reads remain safe.
+    return [{ resource: '*', mode: ['edit_file', 'patch_file', 'terminal_command_run'].includes(capabilityId) ? 'write' : 'read' }];
 }
-// The resource name a file Capability claims for a path. Shared so revert_call names the same
-// resource its target write_file/edit_file Calls named -- claims only detect conflicts if both sides
-// spell the resource identically. Note this is a naive resolve, not a realpath: the vocabulary is
-// internally consistent rather than canonical, which is what conflict detection needs.
-export function pathResource(path, workspacePaths) {
-    return isAbsolute(path) ? resolve(path) : resolve(workspacePaths[0] ?? '*', path);
+export async function verifySharedWorkspace(root, read) {
+    let directory;
+    try {
+        const expected = randomBytes(32).toString('hex');
+        let path;
+        try {
+            directory = await mkdtemp(join(root, '.lens-shared-'));
+            path = join(directory, 'probe');
+            await writeFile(path, expected, { mode: 0o600 });
+        }
+        catch {
+            fail('SHARED_WORKSPACE_REQUIRED', 409, 'Core could not create a shared Workspace probe.');
+        }
+        if (!await read(path, expected))
+            fail('SHARED_WORKSPACE_REQUIRED', 409, 'Core and Executor do not share this Workspace.');
+    }
+    finally {
+        if (directory !== undefined)
+            await rm(directory, { recursive: true, force: true });
+    }
 }
 async function channelCredentials(root, config) {
     if (config.tls?.enabled !== true)
@@ -228,11 +353,20 @@ async function loadIdentity(path) {
     await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
     return value;
 }
-function definition(id, title, description, effect, properties, required) {
-    return { id, title, description, effect, adapterId: 'executor', loadMode: eagerCapabilities.has(id) ? 'eager' : 'deferred', outputLimitBytes: outputLimits[id] ?? 1048576, defaultAssignment: defaultAssignments[id] ?? 'configured', inputSchema: { type: 'object', additionalProperties: false, properties, required } };
+function definition(id, title, description, effect, properties, required, outputSchema) {
+    return { id, title, description, effect, adapterId: 'executor', loadMode: eagerCapabilities.has(id) ? 'eager' : 'deferred', outputLimitBytes: outputLimits[id] ?? 1048576, defaultAssignment: defaultAssignments[id] ?? 'configured', inputSchema: { type: 'object', additionalProperties: false, properties, required }, ...(outputSchema === undefined ? {} : { outputSchema }) };
+}
+function editEntries(value) {
+    if (!Array.isArray(value))
+        fail('INVALID_INPUT', 400, 'edits must be an array.');
+    return value.map((entry) => {
+        const edit = object(jsonValue(entry));
+        return { old_string: string(edit.old_string), new_string: text(edit.new_string), replace_all: edit.replace_all === true };
+    });
 }
 function result(content) {
-    return { content };
+    const value = object(content);
+    return { content, capture: value.truncated === true ? 'partial' : value.truncated === false ? 'complete' : 'unknown' };
 }
 function bounded(value, field) {
     const bytes = Buffer.byteLength(value, 'utf8');
@@ -247,6 +381,7 @@ function processResult(content) {
     const failed = exitCode !== 0 || signal !== undefined;
     return {
         content,
+        capture: value.stdout_truncated === true || value.stderr_truncated === true ? 'partial' : value.stdout_truncated === false && value.stderr_truncated === false ? 'complete' : 'unknown',
         ...(failed ? { outcome: 'failed', errorCode: signal === 'TIMEOUT' ? 'WORKER_TIMEOUT' : signal === 'CANCELLED' ? 'WORKER_CANCELLED' : 'WORKER_EXIT_NONZERO' } : {})
     };
 }

package/dist/adapters/lsp.d.ts

@@ -4,7 +4,8 @@ import type { RegisteredCapability } from '../runtime/capabilities.js';
 export declare class LspPool {
     #private;
     readonly servers: NonNullable<HarnessConfig['lspServers']>;
-    constructor(servers: NonNullable<HarnessConfig['lspServers']>);
+    readonly verifyWorkspace: (paths: readonly string[]) => Promise<void>;
+    constructor(servers: NonNullable<HarnessConfig['lspServers']>, verifyWorkspace?: (paths: readonly string[]) => Promise<void>);
     request(serverId: string, workspacePaths: readonly string[], sessionId: string, method: string, params: Json, signal: AbortSignal): Promise<Json>;
     projectPath(serverId: string, workspacePaths: readonly string[]): string;
     close(): Promise<void>;

package/dist/adapters/lsp.js

@@ -6,24 +6,60 @@ import { LspProcess } from '../execution/lsp-process.js';
 import { capabilityManifest } from '../runtime/manifests.js';
 export class LspPool {
     servers;
+    verifyWorkspace;
     #clients = new Map();
-    constructor(servers) {
+    #closed = false;
+    constructor(servers, verifyWorkspace = async () => { }) {
         this.servers = servers;
+        this.verifyWorkspace = verifyWorkspace;
     }
     async request(serverId, workspacePaths, sessionId, method, params, signal) {
+        signal.throwIfAborted();
+        if (this.#closed)
+            fail('LSP_SERVER_UNAVAILABLE', 503, 'The LSP pool is closed.');
+        await this.verifyWorkspace(workspacePaths);
+        signal.throwIfAborted();
         const projectPath = this.projectPath(serverId, workspacePaths);
         assertFileUris(workspacePaths, params);
-        const selected = await this.#client(serverId, projectPath, sessionId);
+        const config = this.servers[serverId];
+        if (config === undefined)
+            fail('LSP_SERVER_UNAVAILABLE', 404, 'The LSP server is not configured.');
+        const sessionKey = key(serverId, projectPath, sessionId);
+        const restarted = this.#clients.get(sessionKey)?.process.closed ?? true;
+        const client = this.#client(serverId, projectPath, sessionKey);
+        client.active++;
+        if (client.timer !== undefined)
+            clearTimeout(client.timer);
+        const deadline = new AbortController();
+        const timeout = setTimeout(() => deadline.abort(Object.assign(new Error('The LSP request timed out.'), { code: 'LSP_TIMEOUT' })), config.requestTimeoutMs ?? 30000);
+        const combined = AbortSignal.any([signal, deadline.signal, client.controller.signal]);
         try {
+            const process = await abortable(client.promise, combined);
+            let response = null;
             if (isNotification(method))
-                selected.process.notify(method, params);
-            const response = isNotification(method) ? null : jsonValue(await selected.process.request(method, params, signal));
-            return { method, response, notifications: selected.process.drainNotifications().map(jsonValue), restarted: selected.restarted };
+                await process.notify(method, params, false, combined);
+            else
+                response = jsonValue(await process.request(method, params, combined));
+            return { method, response, notifications: process.drainNotifications().map(jsonValue), restarted };
         }
-        catch (error) {
-            if (selected.process.closed)
-                this.#clients.delete(key(serverId, projectPath, sessionId));
-            throw error;
+        finally {
+            clearTimeout(timeout);
+            client.active--;
+            if (!client.ready && client.active === 0) {
+                client.controller.abort(new Error('No callers remain for LSP initialization.'));
+                await client.process.close();
+                if (this.#clients.get(sessionKey) === client)
+                    this.#clients.delete(sessionKey);
+            }
+            else if (client.active === 0 && this.#clients.get(sessionKey) === client) {
+                client.timer = setTimeout(() => {
+                    if (client.active === 0 && this.#clients.get(sessionKey) === client) {
+                        this.#clients.delete(sessionKey);
+                        void client.process.close();
+                    }
+                }, config.idleTimeoutMs ?? 300000);
+                client.timer.unref();
+            }
         }
     }
     projectPath(serverId, workspacePaths) {
@@ -37,44 +73,65 @@ export class LspPool {
         return project;
     }
     async close() {
-        await Promise.allSettled([...this.#clients.values()].map(async (client) => (await client).close()));
+        this.#closed = true;
+        const clients = [...this.#clients.values()];
         this.#clients.clear();
+        for (const client of clients) {
+            if (client.timer !== undefined)
+                clearTimeout(client.timer);
+            client.controller.abort(new Error('The LSP pool closed.'));
+        }
+        await Promise.allSettled(clients.map(client => client.process.close()));
     }
-    async #client(serverId, workspacePath, sessionId) {
-        const sessionKey = key(serverId, workspacePath, sessionId);
-        const existing = this.#clients.get(sessionKey);
-        if (existing !== undefined) {
-            const process = await existing;
-            if (!process.closed)
-                return { process, restarted: false };
-            this.#clients.delete(sessionKey);
+    #client(serverId, workspacePath, sessionKey) {
+        for (const [key, client] of this.#clients) {
+            if (!client.process.closed)
+                continue;
+            if (client.timer !== undefined)
+                clearTimeout(client.timer);
+            this.#clients.delete(key);
+            void client.process.close();
         }
+        const existing = this.#clients.get(sessionKey);
+        if (existing !== undefined)
+            return existing;
         const config = this.servers[serverId];
         if (config === undefined)
-            fail('LSP_SERVER_UNAVAILABLE', 404, `LSP server ${serverId} is not configured.`);
-        const created = Promise.resolve().then(async () => {
-            const process = new LspProcess(config.command, config.args ?? [], workspacePath, config.maxFrameBytes ?? 4194304, config.maxBufferBytes ?? 8388608);
-            await process.request('initialize', {
-                processId: process.pid ?? null,
-                rootUri: pathToFileURL(workspacePath).href,
-                capabilities: {},
-                initializationOptions: config.initializationOptions ?? null
-            }, AbortSignal.timeout(10000));
-            process.markInitialized();
-            process.notify('initialized', {});
-            return process;
-        });
-        this.#clients.set(sessionKey, created);
-        try {
-            return { process: await created, restarted: true };
-        }
-        catch (error) {
-            this.#clients.delete(sessionKey);
-            void created.then((process) => process.close(), () => undefined);
-            throw error;
-        }
+            fail('LSP_SERVER_UNAVAILABLE', 404, 'The LSP server is not configured.');
+        if ([...this.#clients.values()].filter(client => client.serverId === serverId).length >= (config.maxSessions ?? 16))
+            fail('LSP_SESSION_LIMIT', 429, 'The LSP session limit has been reached.');
+        const process = new LspProcess(config.command, config.args ?? [], workspacePath, config.maxFrameBytes ?? 4194304, config.maxBufferBytes ?? 8388608, config.requestTimeoutMs ?? 30000);
+        const client = { serverId, process, controller: new AbortController(), promise: Promise.resolve(process), active: 0, ready: false, timer: undefined };
+        this.#clients.set(sessionKey, client);
+        client.promise = (async () => {
+            try {
+                await process.request('initialize', { processId: null, rootUri: pathToFileURL(workspacePath).href, capabilities: {}, initializationOptions: config.initializationOptions ?? null }, client.controller.signal);
+                client.controller.signal.throwIfAborted();
+                process.markInitialized();
+                await process.notify('initialized', {});
+                client.ready = true;
+                return process;
+            }
+            catch (error) {
+                await process.close();
+                if (this.#clients.get(sessionKey) === client)
+                    this.#clients.delete(sessionKey);
+                throw error;
+            }
+        })();
+        void client.promise.catch(() => undefined);
+        return client;
     }
 }
+function abortable(promise, signal) {
+    if (signal.aborted)
+        return Promise.reject(signal.reason instanceof Error ? signal.reason : new Error('LSP request cancelled.'));
+    return new Promise((resolve, reject) => {
+        const abort = () => { signal.removeEventListener('abort', abort); reject(signal.reason instanceof Error ? signal.reason : new Error('LSP request cancelled.')); };
+        signal.addEventListener('abort', abort, { once: true });
+        void promise.then(value => { signal.removeEventListener('abort', abort); resolve(value); }, (error) => { signal.removeEventListener('abort', abort); reject(error instanceof Error ? error : new Error(String(error))); });
+    });
+}
 export class LspAdapter {
     pool;
     id = 'lsp';
@@ -123,7 +180,7 @@ export function lspCapabilities(config, pool) {
             adapter,
             manifest: capabilityManifest(definition, ['read_only', 'workspace_write']),
             effect: (input) => writeMethods.has(string(object(input).method)) ? 'workspace_write' : 'read_only',
-            claims: (context) => [{ resource: context.workspacePaths[0] ?? '*', mode: writeMethods.has(string(object(context.arguments).method)) ? 'write' : 'read' }]
+            claims: (context) => [{ resource: '*', mode: writeMethods.has(string(object(context.arguments).method)) ? 'write' : 'read' }]
         }];
 }
 const allowedMethods = new Set([