@lensagent/core 0.1.0

package/dist/adapters/lsp.js

@@ -0,0 +1,218 @@
+import { existsSync, realpathSync } from 'node:fs';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { fail } from '../core/domain.js';
+import { LspProcess } from '../execution/lsp-process.js';
+import { capabilityManifest } from '../runtime/manifests.js';
+export class LspPool {
+    servers;
+    #clients = new Map();
+    constructor(servers) {
+        this.servers = servers;
+    }
+    async request(serverId, workspacePaths, sessionId, method, params, signal) {
+        const projectPath = this.projectPath(serverId, workspacePaths);
+        assertFileUris(workspacePaths, params);
+        const selected = await this.#client(serverId, projectPath, sessionId);
+        try {
+            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 };
+        }
+        catch (error) {
+            if (selected.process.closed)
+                this.#clients.delete(key(serverId, projectPath, sessionId));
+            throw error;
+        }
+    }
+    projectPath(serverId, workspacePaths) {
+        const configured = this.servers[serverId]?.project ?? '.';
+        const roots = workspacePaths.map((path) => realpathSync(resolve(path)));
+        const root = isAbsolute(configured) ? roots.find((candidate) => within(candidate, configured)) : roots[0];
+        if (root === undefined)
+            fail('WORKSPACE_INVALID', 400, 'The LSP project is outside the Workspace.');
+        const project = resolve(root, configured);
+        assertRealPath(root, project);
+        return project;
+    }
+    async close() {
+        await Promise.allSettled([...this.#clients.values()].map(async (client) => (await client).close()));
+        this.#clients.clear();
+    }
+    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);
+        }
+        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;
+        }
+    }
+}
+export class LspAdapter {
+    pool;
+    id = 'lsp';
+    constructor(pool) {
+        this.pool = pool;
+    }
+    async execute(invocation) {
+        const input = object(invocation.arguments);
+        const serverId = string(input.server_id);
+        const method = string(input.method);
+        if (!allowedMethods.has(method))
+            fail('CALL_ARGUMENTS_INVALID', 422, `LSP method ${method} is not allowed.`);
+        if (invocation.workspacePaths.length === 0)
+            fail('WORKSPACE_INVALID', 503, 'LSP requires a Workspace root.');
+        return { content: await this.pool.request(serverId, invocation.workspacePaths, optionalString(input.session_id) ?? 'default', method, jsonValue(input.params ?? {}), invocation.signal) };
+    }
+}
+export function lspCapabilities(config, pool) {
+    const serverIds = Object.keys(config).sort();
+    if (serverIds.length === 0)
+        return [];
+    const adapter = new LspAdapter(pool);
+    const definition = {
+        id: 'lsp_request',
+        title: 'LSP request',
+        description: 'Send an allowed request or notification to a configured Language Server.',
+        adapterId: adapter.id,
+        effect: 'read_only',
+        loadMode: 'deferred',
+        outputLimitBytes: 1048576,
+        defaultAssignment: 'configured',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                server_id: { type: 'string', enum: serverIds },
+                session_id: { type: 'string', minLength: 1 },
+                method: { type: 'string', enum: [...allowedMethods] },
+                params: { type: 'object', additionalProperties: true }
+            },
+            required: ['server_id', 'method']
+        }
+    };
+    return [{
+            definition,
+            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' }]
+        }];
+}
+const allowedMethods = new Set([
+    'textDocument/didOpen',
+    'textDocument/didChange',
+    'textDocument/didClose',
+    'textDocument/didSave',
+    'textDocument/diagnostic',
+    'textDocument/hover',
+    'textDocument/definition',
+    'textDocument/references',
+    'textDocument/rename',
+    'textDocument/codeAction',
+    'textDocument/completion',
+    'project/diagnostic',
+    'project/symbol',
+    'workspace/symbol'
+]);
+const writeMethods = new Set(['textDocument/rename', 'textDocument/codeAction']);
+function isNotification(method) {
+    return method.startsWith('textDocument/did');
+}
+function assertFileUris(workspacePaths, value) {
+    if (typeof value === 'string' && value.toLowerCase().startsWith('file:')) {
+        let path;
+        try {
+            path = fileURLToPath(value);
+        }
+        catch {
+            fail('CALL_ARGUMENTS_INVALID', 422, 'The LSP request contains an invalid file URI.');
+        }
+        const roots = workspacePaths.map((root) => realpathSync(resolve(root)));
+        const root = roots.find((candidate) => within(candidate, path));
+        if (root === undefined)
+            fail('CALL_ARGUMENTS_INVALID', 422, 'The LSP request references a file outside the Workspace.');
+        assertRealPath(root, path);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            assertFileUris(workspacePaths, entry);
+    }
+    else if (objectLike(value)) {
+        for (const entry of Object.values(value))
+            assertFileUris(workspacePaths, entry);
+    }
+}
+function assertRealPath(root, target) {
+    if (!within(root, target))
+        fail('CALL_ARGUMENTS_INVALID', 422, 'The LSP path is outside the Workspace.');
+    let existing = target;
+    while (!existsSync(existing)) {
+        const parent = dirname(existing);
+        if (parent === existing)
+            break;
+        existing = parent;
+    }
+    if (!within(root, realpathSync(existing)))
+        fail('CALL_ARGUMENTS_INVALID', 422, 'The LSP path resolves outside the Workspace.');
+}
+function within(root, target) {
+    const relation = relative(root, resolve(target));
+    return relation === '' || (relation !== '..' && !relation.startsWith(`..${sep}`) && !isAbsolute(relation));
+}
+function key(serverId, workspacePath, sessionId) {
+    return `${serverId}\u0000${workspacePath}\u0000${sessionId}`;
+}
+function object(value) {
+    if (!objectLike(value))
+        fail('INVALID_INPUT', 400, 'LSP input must be an object.');
+    return value;
+}
+function objectLike(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function string(value) {
+    if (typeof value !== 'string' || value.length === 0)
+        fail('INVALID_INPUT', 400, 'A required LSP string is missing.');
+    return value;
+}
+function optionalString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function jsonValue(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number')
+        return value;
+    if (Array.isArray(value))
+        return value.map(jsonValue);
+    if (typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, jsonValue(entry)]));
+    fail('LSP_PROTOCOL_ERROR', 502, 'LSP returned a non-JSON value.');
+}

package/dist/adapters/mcp.d.ts

@@ -0,0 +1,32 @@
+import { type CapabilityAdapter, type CapabilityInvocation, type CapabilityOutput, type Json } from '../core/domain.js';
+import type { HarnessConfig } from '../config/schema.js';
+import type { RegisteredCapability } from '../runtime/capabilities.js';
+interface McpTool {
+    readonly name: string;
+    readonly title?: string;
+    readonly description?: string;
+    readonly inputSchema: Readonly<Record<string, Json>>;
+    readonly outputSchema?: Readonly<Record<string, Json>>;
+}
+export declare class McpElicitationError extends Error {
+    readonly prompt: Json;
+    constructor(prompt: Json);
+}
+export declare class McpClient {
+    readonly id: string;
+    readonly config: NonNullable<HarnessConfig['mcpServers']>[string];
+    readonly headers: Readonly<Record<string, string>>;
+    constructor(id: string, config: NonNullable<HarnessConfig['mcpServers']>[string]);
+    discover(signal?: AbortSignal): Promise<readonly McpTool[]>;
+    call(name: string, argumentsValue: Json, answer: Json | undefined, requestState: string | undefined, signal: AbortSignal): Promise<Json>;
+    request(method: string, params: Json, signal?: AbortSignal): Promise<Json>;
+}
+export declare class McpAdapter implements CapabilityAdapter {
+    readonly serverId: string;
+    readonly client: McpClient;
+    readonly id: string;
+    constructor(serverId: string, client: McpClient);
+    execute(invocation: CapabilityInvocation): Promise<CapabilityOutput>;
+}
+export declare function mcpCapabilities(serverId: string, config: NonNullable<HarnessConfig['mcpServers']>[string]): Promise<readonly RegisteredCapability[]>;
+export {};

package/dist/adapters/mcp.js

@@ -0,0 +1,283 @@
+import { randomUUID } from 'node:crypto';
+import { fail } from '../core/domain.js';
+import { capabilityManifest } from '../runtime/manifests.js';
+import { componentIdentity } from '../core/identity.js';
+const protocolVersion = '2026-07-28';
+export class McpElicitationError extends Error {
+    prompt;
+    constructor(prompt) {
+        super('MCP server requires user input.');
+        this.prompt = prompt;
+        this.name = 'McpElicitationError';
+    }
+}
+export class McpClient {
+    id;
+    config;
+    headers;
+    constructor(id, config) {
+        this.id = id;
+        this.config = config;
+        this.headers = resolveHeaders(id, config.headers ?? {});
+    }
+    async discover(signal) {
+        const tools = [];
+        const cursors = new Set();
+        let cursor;
+        do {
+            const result = object(await this.request('tools/list', cursor === undefined ? {} : { cursor }, signal));
+            if (!Array.isArray(result.tools))
+                fail('MCP_PROTOCOL_ERROR', 502, `MCP server ${this.id} returned an invalid tools/list result.`);
+            tools.push(...result.tools.map(tool));
+            if (result.nextCursor === undefined)
+                cursor = undefined;
+            else {
+                cursor = string(result.nextCursor);
+                if (cursors.has(cursor))
+                    fail('MCP_PROTOCOL_ERROR', 502, `MCP server ${this.id} repeated a tools/list cursor.`);
+                cursors.add(cursor);
+            }
+        } while (cursor !== undefined);
+        return tools.sort((left, right) => left.name.localeCompare(right.name));
+    }
+    async call(name, argumentsValue, answer, requestState, signal) {
+        const result = object(await this.request('tools/call', {
+            name,
+            arguments: argumentsValue,
+            ...(answer === undefined ? {} : { inputResponses: answer }),
+            ...(requestState === undefined ? {} : { requestState })
+        }, signal));
+        if (result.resultType === 'input_required') {
+            const inputRequests = result.inputRequests === undefined ? {} : object(result.inputRequests);
+            const state = result.requestState === undefined ? undefined : string(result.requestState);
+            throw new McpElicitationError({
+                kind: 'mcp_input_required',
+                input_requests: jsonValue(inputRequests),
+                ...(state === undefined ? {} : { request_state: state })
+            });
+        }
+        return jsonValue(result);
+    }
+    async request(method, params, signal) {
+        const id = randomUUID();
+        const controller = new AbortController();
+        const onAbort = () => controller.abort(signal?.reason);
+        signal?.addEventListener('abort', onAbort, { once: true });
+        const timeout = setTimeout(() => controller.abort(new Error('MCP request timed out.')), this.config.timeoutMs ?? 30000);
+        try {
+            let response;
+            try {
+                response = await fetch(this.config.endpoint, {
+                    method: 'POST',
+                    signal: controller.signal,
+                    headers: {
+                        ...this.headers,
+                        'content-type': 'application/json',
+                        accept: 'application/json, text/event-stream',
+                        'mcp-protocol-version': protocolVersion
+                    },
+                    body: JSON.stringify({
+                        jsonrpc: '2.0',
+                        id,
+                        method,
+                        params: {
+                            ...object(params),
+                            _meta: {
+                                'io.modelcontextprotocol/protocolVersion': protocolVersion,
+                                // Read from the installed package metadata rather than repeated here. A literal
+                                // was pinned to 0.1.0 and told every MCP server the wrong version from the first
+                                // release onwards, because nothing makes a hand-copied version follow a bump.
+                                'io.modelcontextprotocol/clientInfo': { name: 'Lens', version: componentIdentity().softwareVersion },
+                                'io.modelcontextprotocol/clientCapabilities': { elicitation: { form: {}, url: {} } }
+                            }
+                        }
+                    })
+                });
+            }
+            catch (error) {
+                if (signal?.aborted === true)
+                    throw signal.reason;
+                fail('MCP_SERVER_UNAVAILABLE', 502, `MCP server ${this.id} could not be reached.`, { cause: error instanceof Error ? error.message : String(error) });
+            }
+            const source = await boundedText(response, this.config.outputLimitBytes ?? 1048576);
+            const envelopes = response.headers.get('content-type')?.includes('text/event-stream') === true
+                ? sseData(source).map(parseEnvelope)
+                : [parseEnvelope(source)];
+            const document = envelopes.find((entry) => entry.id === id);
+            if (document === undefined || document.jsonrpc !== '2.0')
+                fail('MCP_PROTOCOL_ERROR', 502, `MCP server ${this.id} returned an invalid JSON-RPC response.`);
+            if (document.error !== undefined)
+                fail('MCP_PROTOCOL_ERROR', 502, `MCP server ${this.id} returned a JSON-RPC error.`, { error: jsonValue(document.error) });
+            if (!response.ok)
+                fail('MCP_SERVER_UNAVAILABLE', 502, `MCP server ${this.id} returned HTTP ${response.status}.`);
+            if (!Object.hasOwn(document, 'result'))
+                fail('MCP_PROTOCOL_ERROR', 502, `MCP server ${this.id} returned no result.`);
+            return jsonValue(document.result);
+        }
+        finally {
+            clearTimeout(timeout);
+            signal?.removeEventListener('abort', onAbort);
+        }
+    }
+}
+export class McpAdapter {
+    serverId;
+    client;
+    id;
+    constructor(serverId, client) {
+        this.serverId = serverId;
+        this.client = client;
+        this.id = `mcp:${serverId}`;
+    }
+    async execute(invocation) {
+        const separator = invocation.capabilityId.indexOf('/', 4);
+        if (separator < 0)
+            fail('CAPABILITY_NOT_FOUND', 404, 'The MCP Capability ID is invalid.');
+        const input = object(invocation.arguments);
+        const argumentsValue = input.arguments === undefined ? invocation.arguments : jsonValue(input.arguments);
+        const answer = input.answer === undefined ? undefined : jsonValue(input.answer);
+        const prompt = input.prompt === undefined ? undefined : object(input.prompt);
+        const requestState = prompt?.request_state === undefined ? undefined : string(prompt.request_state);
+        return output(await this.client.call(invocation.capabilityId.slice(separator + 1), argumentsValue, answer, requestState, invocation.signal));
+    }
+}
+export async function mcpCapabilities(serverId, config) {
+    const client = new McpClient(serverId, config);
+    const adapter = new McpAdapter(serverId, client);
+    const definitions = new Map();
+    for (const entry of await client.discover()) {
+        const id = `mcp:${serverId}/${entry.name}`;
+        if (definitions.has(id))
+            continue;
+        definitions.set(id, {
+            id,
+            title: entry.title ?? entry.name,
+            description: entry.description ?? `MCP tool ${entry.name} from ${serverId}.`,
+            inputSchema: entry.inputSchema,
+            ...(entry.outputSchema === undefined ? {} : { outputSchema: entry.outputSchema }),
+            effect: 'full',
+            adapterId: adapter.id,
+            loadMode: 'deferred',
+            outputLimitBytes: config.outputLimitBytes ?? 1048576,
+            defaultAssignment: 'configured'
+        });
+    }
+    return [...definitions.values()].map((definition) => ({
+        definition,
+        adapter,
+        manifest: capabilityManifest(definition),
+        claims: () => [{ resource: `mcp:${serverId}`, mode: 'write' }]
+    }));
+}
+function tool(value) {
+    const source = object(value);
+    return {
+        name: string(source.name),
+        ...(typeof source.title === 'string' ? { title: source.title } : {}),
+        ...(typeof source.description === 'string' ? { description: source.description } : {}),
+        inputSchema: schema(source.inputSchema),
+        ...(source.outputSchema === undefined ? {} : { outputSchema: schema(source.outputSchema) })
+    };
+}
+function output(value) {
+    const result = object(value);
+    if (!Array.isArray(result.content))
+        fail('MCP_PROTOCOL_ERROR', 502, 'MCP tools/call returned invalid content.');
+    const text = [];
+    const links = [];
+    const artifacts = [];
+    for (const [index, candidate] of result.content.entries()) {
+        const block = object(candidate);
+        if (block.type === 'text')
+            text.push(string(block.text));
+        else if (block.type === 'image' || block.type === 'audio')
+            artifacts.push(binaryArtifact(block, `mcp-${block.type}-${index}`));
+        else if (block.type === 'resource_link')
+            links.push(jsonValue(block));
+        else if (block.type === 'resource') {
+            const resource = object(block.resource);
+            if (typeof resource.text === 'string')
+                text.push(resource.text);
+            else if (typeof resource.blob === 'string')
+                artifacts.push(binaryArtifact(resource, `mcp-resource-${index}`));
+            else
+                links.push(jsonValue(resource));
+        }
+        else
+            fail('MCP_PROTOCOL_ERROR', 502, 'MCP tools/call returned an unsupported content block.');
+    }
+    const content = {
+        text: text.join('\n'),
+        ...(result.structuredContent === undefined ? {} : { structured_content: jsonValue(result.structuredContent) }),
+        ...(links.length === 0 ? {} : { resource_links: links })
+    };
+    return {
+        content,
+        ...(artifacts.length === 0 ? {} : { artifacts }),
+        ...(result.isError === true ? { outcome: 'failed', errorCode: 'MCP_TOOL_EXECUTION_FAILED' } : {})
+    };
+}
+function binaryArtifact(value, name) {
+    return {
+        name,
+        mediaType: typeof value.mimeType === 'string' ? value.mimeType : 'application/octet-stream',
+        bytes: Buffer.from(string(value.data ?? value.blob), 'base64')
+    };
+}
+function resolveHeaders(serverId, headers) {
+    const result = {};
+    for (const [name, reference] of Object.entries(headers)) {
+        if (typeof reference === 'string')
+            result[name] = reference;
+        else {
+            const value = process.env[reference.env];
+            if (value !== undefined && value.length > 0)
+                result[name] = value;
+            else if (reference.optional !== true)
+                fail('MCP_SERVER_UNAVAILABLE', 503, `MCP server ${serverId} requires environment variable ${reference.env}.`);
+        }
+    }
+    return result;
+}
+async function boundedText(response, limit) {
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.byteLength > limit)
+        fail('MCP_PROTOCOL_ERROR', 502, 'MCP response exceeded its configured limit.');
+    return bytes.toString();
+}
+function sseData(source) {
+    return source.replaceAll('\r\n', '\n').replaceAll('\r', '\n').split('\n\n').flatMap((block) => {
+        const data = block.split('\n').filter((line) => line.startsWith('data:')).map((line) => line.slice(5).trimStart());
+        return data.length === 0 ? [] : [data.join('\n')];
+    });
+}
+function parseEnvelope(source) {
+    try {
+        return object(JSON.parse(source));
+    }
+    catch {
+        fail('MCP_PROTOCOL_ERROR', 502, 'MCP returned invalid JSON.');
+    }
+}
+function object(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        fail('MCP_PROTOCOL_ERROR', 502, 'MCP returned an invalid object.');
+    return value;
+}
+function schema(value) {
+    return object(jsonValue(value));
+}
+function string(value) {
+    if (typeof value !== 'string' || value.length === 0)
+        fail('MCP_PROTOCOL_ERROR', 502, 'MCP returned an invalid string.');
+    return value;
+}
+function jsonValue(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number')
+        return value;
+    if (Array.isArray(value))
+        return value.map(jsonValue);
+    if (typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, jsonValue(entry)]));
+    fail('MCP_PROTOCOL_ERROR', 502, 'MCP returned a non-JSON value.');
+}

package/dist/adapters/revert.d.ts

@@ -0,0 +1,12 @@
+import { type CapabilityAdapter, type CapabilityInvocation, type CapabilityOutput } from '../core/domain.js';
+import type { RegisteredCapability } from '../runtime/capabilities.js';
+import type { Store } from '../store/store.js';
+import { type ExecutorClient } from './executor.js';
+export declare class RevertAdapter implements CapabilityAdapter {
+    readonly store: Store;
+    readonly executor: ExecutorClient;
+    readonly id = "revert";
+    constructor(store: Store, executor: ExecutorClient);
+    execute(invocation: CapabilityInvocation): Promise<CapabilityOutput>;
+}
+export declare function revertCapabilities(store: Store, executor: ExecutorClient): readonly RegisteredCapability[];