@lensagent/core 0.1.0

package/dist/execution/lsp-process.js

@@ -0,0 +1,234 @@
+import { spawn } from 'node:child_process';
+export class LspProcess {
+    maxFrameBytes;
+    maxBufferBytes;
+    #child;
+    #pending = new Map();
+    #notifications = [];
+    #notificationBytes = 0;
+    #buffer = Buffer.alloc(0);
+    #nextId = 1;
+    #initialized = false;
+    #closed = false;
+    #closing;
+    constructor(command, args, cwd, maxFrameBytes, maxBufferBytes) {
+        this.maxFrameBytes = maxFrameBytes;
+        this.maxBufferBytes = maxBufferBytes;
+        this.#child = spawn(command, args, { cwd, env: processEnvironment(), shell: false, windowsHide: true });
+        this.#child.stdout.on('data', (chunk) => this.#receive(chunk));
+        this.#child.stdin.on('error', () => this.#fail(lspError('LSP_SERVER_UNAVAILABLE', 'The LSP input stream failed.')));
+        this.#child.once('error', () => this.#fail(lspError('LSP_SERVER_UNAVAILABLE', 'The LSP server could not start.')));
+        this.#child.once('close', () => this.#fail(lspError('LSP_SERVER_UNAVAILABLE', 'The LSP server exited.')));
+    }
+    get pid() {
+        return this.#child.pid;
+    }
+    get initialized() {
+        return this.#initialized;
+    }
+    get closed() {
+        return this.#closed;
+    }
+    markInitialized() {
+        this.#initialized = true;
+    }
+    request(method, params, signal, allowClosing = false) {
+        if (this.#closed || (this.#closing !== undefined && !allowClosing))
+            return Promise.reject(lspError('LSP_SERVER_UNAVAILABLE', 'The LSP session is closed.'));
+        if (signal?.aborted === true)
+            return Promise.reject(abortError(signal.reason));
+        const id = this.#nextId++;
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                if (!this.#pending.delete(id))
+                    return;
+                try {
+                    this.notify('$/cancelRequest', { id }, allowClosing);
+                }
+                catch { /* The local cancellation remains authoritative. */ }
+                reject(abortError(signal?.reason));
+            };
+            const finish = (operation) => {
+                signal?.removeEventListener('abort', onAbort);
+                operation();
+            };
+            this.#pending.set(id, {
+                resolve: (value) => finish(() => resolve(value)),
+                reject: (error) => finish(() => reject(error))
+            });
+            signal?.addEventListener('abort', onAbort, { once: true });
+            try {
+                this.#send({ jsonrpc: '2.0', id, method, params });
+            }
+            catch (error) {
+                this.#pending.delete(id);
+                finish(() => reject(asError(error)));
+            }
+        });
+    }
+    notify(method, params, allowClosing = false) {
+        if (this.#closed || (this.#closing !== undefined && !allowClosing))
+            throw lspError('LSP_SERVER_UNAVAILABLE', 'The LSP session is closed.');
+        this.#send({ jsonrpc: '2.0', method, params });
+    }
+    drainNotifications() {
+        const result = this.#notifications.splice(0);
+        this.#notificationBytes = 0;
+        return result;
+    }
+    close() {
+        this.#closing ??= this.#shutdown();
+        return this.#closing;
+    }
+    async #shutdown() {
+        if (this.#initialized && !this.#closed) {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 1000);
+            try {
+                await this.request('shutdown', null, controller.signal, true);
+            }
+            catch { /* Process termination follows. */ }
+            finally {
+                clearTimeout(timeout);
+            }
+            try {
+                this.notify('exit', null, true);
+            }
+            catch { /* The process may already be gone. */ }
+        }
+        await terminate(this.#child);
+        this.#fail(lspError('LSP_SERVER_UNAVAILABLE', 'The LSP session was closed.'));
+    }
+    #send(value) {
+        if (!this.#child.stdin.writable)
+            throw lspError('LSP_SERVER_UNAVAILABLE', 'The LSP server is not writable.');
+        const content = Buffer.from(JSON.stringify(value));
+        if (content.byteLength > this.maxFrameBytes)
+            throw lspError('LSP_PROTOCOL_ERROR', 'The LSP frame exceeds the configured limit.');
+        this.#child.stdin.write(`Content-Length: ${content.byteLength}\r\n\r\n`);
+        this.#child.stdin.write(content);
+    }
+    #receive(chunk) {
+        if (this.#closed)
+            return;
+        if (this.#buffer.byteLength + chunk.byteLength > this.maxBufferBytes) {
+            this.#protocolFailure('The LSP response buffer exceeds the configured limit.');
+            return;
+        }
+        this.#buffer = Buffer.concat([this.#buffer, chunk]);
+        try {
+            for (;;) {
+                const boundary = this.#buffer.indexOf('\r\n\r\n');
+                if (boundary < 0) {
+                    if (this.#buffer.byteLength > 8192)
+                        throw new Error('The LSP header exceeds the configured limit.');
+                    return;
+                }
+                const headers = this.#buffer.subarray(0, boundary).toString('ascii').split('\r\n');
+                const lengths = headers.flatMap((line) => {
+                    const match = /^Content-Length:\s*(\d+)\s*$/i.exec(line);
+                    return match?.[1] === undefined ? [] : [Number(match[1])];
+                });
+                if (lengths.length !== 1 || !Number.isSafeInteger(lengths[0]) || (lengths[0] ?? 0) > this.maxFrameBytes)
+                    throw new Error('The LSP Content-Length header is invalid.');
+                const start = boundary + 4;
+                const length = lengths[0] ?? 0;
+                if (this.#buffer.byteLength < start + length)
+                    return;
+                const source = this.#buffer.subarray(start, start + length).toString();
+                this.#buffer = this.#buffer.subarray(start + length);
+                const message = JSON.parse(source);
+                if (!record(message))
+                    throw new Error('The LSP message is not an object.');
+                this.#dispatch(message);
+            }
+        }
+        catch (error) {
+            this.#protocolFailure(asError(error).message);
+        }
+    }
+    #dispatch(message) {
+        if (typeof message.method === 'string') {
+            if (typeof message.id === 'number' || typeof message.id === 'string') {
+                this.#send({ jsonrpc: '2.0', id: message.id, error: { code: -32601, message: 'Server-initiated requests are not supported.' } });
+            }
+            else {
+                const bytes = Buffer.byteLength(JSON.stringify(message));
+                while (this.#notifications.length > 0 && (this.#notifications.length >= 128 || this.#notificationBytes + bytes > this.maxBufferBytes)) {
+                    const removed = this.#notifications.shift();
+                    this.#notificationBytes -= Buffer.byteLength(JSON.stringify(removed));
+                }
+                if (bytes <= this.maxBufferBytes) {
+                    this.#notifications.push(message);
+                    this.#notificationBytes += bytes;
+                }
+            }
+            return;
+        }
+        if (typeof message.id !== 'number')
+            return;
+        const pending = this.#pending.get(message.id);
+        if (pending === undefined)
+            return;
+        this.#pending.delete(message.id);
+        if (message.error !== undefined)
+            pending.reject(lspError('LSP_PROTOCOL_ERROR', 'The LSP server rejected the request.'));
+        else
+            pending.resolve(message.result ?? null);
+    }
+    #protocolFailure(message) {
+        this.#fail(lspError('LSP_PROTOCOL_ERROR', message));
+        void terminate(this.#child);
+    }
+    #fail(error) {
+        if (this.#closed && this.#pending.size === 0)
+            return;
+        this.#closed = true;
+        for (const pending of this.#pending.values())
+            pending.reject(error);
+        this.#pending.clear();
+    }
+}
+// Duplicated from executor/src/execution/process.ts (processEnvironment) on purpose: core and
+// executor are independent, non-shared projects. If this allowlist changes, mirror the change
+// in both files.
+function processEnvironment(explicit = {}) {
+    const bootstrap = new Set(['COMSPEC', 'LANG', 'LANGUAGE', 'LC_ALL', 'LC_CTYPE', 'PATH', 'PATHEXT', 'SYSTEMROOT', 'TEMP', 'TMP', 'TMPDIR', 'TZ', 'WINDIR']);
+    const allowed = new Set([...bootstrap, 'APPDATA', 'CI', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'LOCALAPPDATA', 'NODE_ENV', 'NO_PROXY', 'USER', 'USERPROFILE', 'USERNAME', 'XDG_CACHE_HOME', 'XDG_CONFIG_HOME', 'XDG_DATA_HOME']);
+    const normalize = (name) => process.platform === 'win32' ? name.toUpperCase() : name;
+    const selected = new Map();
+    for (const [name, value] of Object.entries(process.env)) {
+        const key = normalize(name);
+        if (value !== undefined && bootstrap.has(key))
+            selected.set(key, [name, value]);
+    }
+    for (const [name, value] of Object.entries(explicit)) {
+        const key = normalize(name);
+        if (allowed.has(key))
+            selected.set(key, [name, value]);
+    }
+    return Object.fromEntries(selected.values());
+}
+async function terminate(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    const closed = new Promise((resolve) => child.once('close', () => resolve()));
+    child.kill('SIGTERM');
+    const graceful = await Promise.race([closed.then(() => true), new Promise((resolve) => setTimeout(() => resolve(false), 1000))]);
+    if (!graceful) {
+        child.kill('SIGKILL');
+        await closed;
+    }
+}
+function lspError(code, message) {
+    return Object.assign(new Error(message), { code });
+}
+function abortError(reason) {
+    return reason instanceof Error ? reason : new Error('The LSP request was cancelled.');
+}
+function asError(value) {
+    return value instanceof Error ? value : new Error(String(value));
+}
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/http/server.d.ts

@@ -0,0 +1,34 @@
+import { type FastifyInstance } from 'fastify';
+import type { PairStore } from '../core/access.js';
+import type { ConfigRuntime } from '../config/runtime.js';
+import type { Store } from '../store/store.js';
+import type { EventBus } from '../runtime/events.js';
+import type { AiModelGateway } from '../runtime/model.js';
+import type { ProjectRuntime } from '../runtime/projects.js';
+import type { ArtifactStore } from '../runtime/artifacts.js';
+import type { Observability } from '../runtime/observability.js';
+import type { ExecutorClient } from '../adapters/executor.js';
+interface Dependencies {
+    readonly https?: {
+        readonly key: Buffer;
+        readonly cert: Buffer;
+    };
+    readonly config: ConfigRuntime;
+    readonly pair: PairStore;
+    readonly store: Store;
+    readonly events: EventBus;
+    readonly models: AiModelGateway;
+    readonly artifacts: ArtifactStore;
+    readonly observability: Observability;
+    readonly executor: ExecutorClient;
+    readonly defaultProjectId: string;
+    readonly runtime: (projectId: string) => ProjectRuntime;
+    readonly refreshProject: (projectId: string) => void;
+    readonly ready: () => {
+        readonly mode: 'health_only' | 'full';
+        readonly blockers: readonly string[];
+    };
+    readonly requestShutdown: () => void;
+}
+export declare function createServer(dependencies: Dependencies): FastifyInstance;
+export {};