@lensagent/core 0.1.0 → 0.1.2

package/dist/execution/lsp-process.d.ts

@@ -2,13 +2,14 @@ export declare class LspProcess {
     #private;
     readonly maxFrameBytes: number;
     readonly maxBufferBytes: number;
-    constructor(command: string, args: readonly string[], cwd: string, maxFrameBytes: number, maxBufferBytes: number);
+    readonly requestTimeoutMs: number;
+    constructor(command: string, args: readonly string[], cwd: string, maxFrameBytes: number, maxBufferBytes: number, requestTimeoutMs?: number);
     get pid(): number | undefined;
     get initialized(): boolean;
     get closed(): boolean;
     markInitialized(): void;
     request(method: string, params: unknown, signal?: AbortSignal, allowClosing?: boolean): Promise<unknown>;
-    notify(method: string, params: unknown, allowClosing?: boolean): void;
+    notify(method: string, params: unknown, allowClosing?: boolean, signal?: AbortSignal): Promise<void>;
     drainNotifications(): readonly unknown[];
     close(): Promise<void>;
 }

package/dist/execution/lsp-process.js

@@ -1,7 +1,9 @@
+import { once } from 'node:events';
 import { spawn } from 'node:child_process';
 export class LspProcess {
     maxFrameBytes;
     maxBufferBytes;
+    requestTimeoutMs;
     #child;
     #pending = new Map();
     #notifications = [];
@@ -11,10 +13,15 @@ export class LspProcess {
     #initialized = false;
     #closed = false;
     #closing;
-    constructor(command, args, cwd, maxFrameBytes, maxBufferBytes) {
+    #writeTail = Promise.resolve();
+    #queuedBytes = 0;
+    #lifetime = new AbortController();
+    constructor(command, args, cwd, maxFrameBytes, maxBufferBytes, requestTimeoutMs = 30000) {
         this.maxFrameBytes = maxFrameBytes;
         this.maxBufferBytes = maxBufferBytes;
+        this.requestTimeoutMs = requestTimeoutMs;
         this.#child = spawn(command, args, { cwd, env: processEnvironment(), shell: false, windowsHide: true });
+        this.#child.stderr.resume();
         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.')));
@@ -37,39 +44,39 @@ export class LspProcess {
             return Promise.reject(lspError('LSP_SERVER_UNAVAILABLE', 'The LSP session is closed.'));
         if (signal?.aborted === true)
             return Promise.reject(abortError(signal.reason));
+        if (this.#pending.size >= 128)
+            return Promise.reject(lspError('LSP_PROTOCOL_ERROR', 'Too many pending LSP requests.'));
+        const deadline = new AbortController();
+        const timeout = setTimeout(() => deadline.abort(lspError('LSP_SERVER_UNAVAILABLE', 'The LSP request timed out.')), this.requestTimeoutMs);
+        signal = signal === undefined ? deadline.signal : AbortSignal.any([signal, deadline.signal]);
         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));
+                void this.notify('$/cancelRequest', { id }, allowClosing).catch(() => undefined);
+                finish(() => reject(abortError(signal.reason)));
             };
             const finish = (operation) => {
-                signal?.removeEventListener('abort', onAbort);
+                clearTimeout(timeout);
+                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) {
+            signal.addEventListener('abort', onAbort, { once: true });
+            void this.#send({ jsonrpc: '2.0', id, method, params }, signal).catch((error) => {
                 this.#pending.delete(id);
                 finish(() => reject(asError(error)));
-            }
+            });
         });
     }
-    notify(method, params, allowClosing = false) {
+    async notify(method, params, allowClosing = false, signal) {
         if (this.#closed || (this.#closing !== undefined && !allowClosing))
             throw lspError('LSP_SERVER_UNAVAILABLE', 'The LSP session is closed.');
-        this.#send({ jsonrpc: '2.0', method, params });
+        await this.#send({ jsonrpc: '2.0', method, params }, signal);
     }
     drainNotifications() {
         const result = this.#notifications.splice(0);
@@ -86,27 +93,34 @@ export class LspProcess {
             const timeout = setTimeout(() => controller.abort(), 1000);
             try {
                 await this.request('shutdown', null, controller.signal, true);
+                await this.notify('exit', null, true, controller.signal);
             }
             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.');
+    #send(value, signal) {
         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);
+            return Promise.reject(lspError('LSP_PROTOCOL_ERROR', 'The LSP frame exceeds the configured limit.'));
+        const frame = Buffer.concat([Buffer.from(`Content-Length: ${content.byteLength}\r\n\r\n`), content]);
+        if (this.#queuedBytes + frame.byteLength > this.maxBufferBytes)
+            return Promise.reject(lspError('LSP_PROTOCOL_ERROR', 'The LSP write queue is full.'));
+        this.#queuedBytes += frame.byteLength;
+        const combined = signal === undefined ? this.#lifetime.signal : AbortSignal.any([signal, this.#lifetime.signal]);
+        const operation = this.#writeTail.then(async () => {
+            combined.throwIfAborted();
+            if (!this.#child.stdin.writable)
+                throw lspError('LSP_SERVER_UNAVAILABLE', 'The LSP server is not writable.');
+            if (!this.#child.stdin.write(frame))
+                await once(this.#child.stdin, 'drain', { signal: combined });
+        }).finally(() => { this.#queuedBytes -= frame.byteLength; });
+        this.#writeTail = operation.catch(() => undefined);
+        return operation;
     }
     #receive(chunk) {
         if (this.#closed)
@@ -150,7 +164,7 @@ export class LspProcess {
     #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.' } });
+                void this.#send({ jsonrpc: '2.0', id: message.id, error: { code: -32601, message: 'Server-initiated requests are not supported.' } }).catch((error) => this.#protocolFailure(asError(error).message));
             }
             else {
                 const bytes = Buffer.byteLength(JSON.stringify(message));
@@ -184,6 +198,7 @@ export class LspProcess {
         if (this.#closed && this.#pending.size === 0)
             return;
         this.#closed = true;
+        this.#lifetime.abort(error);
         for (const pending of this.#pending.values())
             pending.reject(error);
         this.#pending.clear();
@@ -210,11 +225,14 @@ function processEnvironment(explicit = {}) {
     return Object.fromEntries(selected.values());
 }
 async function terminate(child) {
-    if (child.exitCode !== null || child.signalCode !== null)
+    if (child.pid === undefined || 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))]);
+    let timer;
+    const graceful = await Promise.race([closed.then(() => true), new Promise((resolve) => { timer = setTimeout(() => resolve(false), 1000); })]);
+    if (timer !== undefined)
+        clearTimeout(timer);
     if (!graceful) {
         child.kill('SIGKILL');
         await closed;

package/dist/http/server.d.ts

@@ -8,7 +8,10 @@ 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';
+import type { ExecutorRouter } from '../adapters/executor-router.js';
+import type { TaskAuditReader } from '../runtime/task-audit.js';
 interface Dependencies {
+    readonly taskAudit?: TaskAuditReader;
     readonly https?: {
         readonly key: Buffer;
         readonly cert: Buffer;
@@ -21,6 +24,8 @@ interface Dependencies {
     readonly artifacts: ArtifactStore;
     readonly observability: Observability;
     readonly executor: ExecutorClient;
+    readonly executorRouter?: ExecutorRouter;
+    readonly localExecutor?: ExecutorClient;
     readonly defaultProjectId: string;
     readonly runtime: (projectId: string) => ProjectRuntime;
     readonly refreshProject: (projectId: string) => void;