@sema-agent/server 7.147.0 → 7.149.0

package/dist/lsp/manager.js

@@ -1,127 +0,0 @@
-import path from "node:path";
-import { TransportLspSession, LspDiagnosticsRegistry, settleOnAbort } from "@sema-agent/core";
-export function isLspCapable(env) {
-    const e = env;
-    return typeof e.getHost === "function" && typeof e.startBackground === "function" && typeof e.workspaceHandle === "function";
-}
-const DEFAULT_EXT_TO_LANG = {
-    ".ts": "typescript",
-    ".tsx": "typescript",
-    ".mts": "typescript",
-    ".cts": "typescript",
-    ".js": "javascript",
-    ".jsx": "javascript",
-    ".mjs": "javascript",
-    ".cjs": "javascript",
-    ".py": "python",
-    ".go": "go",
-    ".dart": "dart",
-    ".kt": "kotlin",
-    ".kts": "kotlin",
-    ".java": "java",
-    ".swift": "swift",
-    ".rs": "rust",
-};
-export class E2bLspManager {
-    perEnv = new WeakMap();
-    lastFailure = new WeakMap();
-    factory;
-    extToLang;
-    log;
-    hasServerCommand;
-    metrics;
-    diagnostics = new LspDiagnosticsRegistry();
-    constructor(opts) {
-        this.factory = opts.transportFactory;
-        this.extToLang = opts.extToLang ?? DEFAULT_EXT_TO_LANG;
-        this.log = opts.log ?? (() => { });
-        this.hasServerCommand = opts.hasServerCommand ?? (() => true);
-        this.metrics = opts.metrics;
-    }
-    unavailableReason(filePath, env) {
-        if (!env || !isLspCapable(env))
-            return "env-not-lsp-capable";
-        const language = this.extToLang[path.extname(filePath).toLowerCase()];
-        if (!language)
-            return "language-not-mapped";
-        if (!this.hasServerCommand(language))
-            return "no-server-command";
-        return this.lastFailure.get(env)?.get(language);
-    }
-    async sessionFor(filePath, signal, env) {
-        if (!env || !isLspCapable(env))
-            return undefined;
-        const language = this.extToLang[path.extname(filePath).toLowerCase()];
-        if (!language)
-            return undefined;
-        let sessions = this.perEnv.get(env);
-        if (!sessions) {
-            sessions = new Map();
-            this.perEnv.set(env, sessions);
-        }
-        let pending = sessions.get(language) ?? this.startJob(env, sessions, language);
-        let session = await settleOnAbort(pending, signal, () => undefined);
-        if (session?.closed) {
-            const carry = session.openedFiles();
-            pending = sessions.get(language) === pending ? this.startJob(env, sessions, language, { carry }) : sessions.get(language);
-            session = await settleOnAbort(pending, signal, () => undefined);
-        }
-        return session;
-    }
-    startJob(env, sessions, language, heal) {
-        const job = this.open(language, env)
-            .then(async (session) => {
-            if (!session) {
-                if (sessions.get(language) === job)
-                    sessions.delete(language);
-                this.log(heal ? "lsp_session_heal_failed" : "lsp_session_open_failed", { language, ...(heal ? { carried: heal.carry.length } : {}) });
-                this.metrics?.inc(heal ? "lsp_session_heal_total" : "lsp_session_open_total", heal ? { outcome: "failed" } : { language, outcome: "failed" });
-                return undefined;
-            }
-            if (heal)
-                await session.warmOpen(heal.carry).catch(() => ({ opened: 0, failed: heal.carry.length, deferred: 0 }));
-            if (sessions.get(language) !== job) {
-                await session.close().catch(() => undefined);
-                return undefined;
-            }
-            this.log(heal ? "lsp_session_heal" : "lsp_session_open", { language, ...(heal ? { carried: heal.carry.length } : {}) });
-            this.metrics?.inc(heal ? "lsp_session_heal_total" : "lsp_session_open_total", heal ? { outcome: "ok" } : { language, outcome: "ok" });
-            return session;
-        })
-            .catch((e) => {
-            if (sessions.get(language) === job)
-                sessions.delete(language);
-            this.log(heal ? "lsp_session_heal_failed" : "lsp_session_open_failed", {
-                language,
-                error: e instanceof Error ? e.message : String(e),
-                ...(heal ? { carried: heal.carry.length } : {}),
-            });
-            this.metrics?.inc(heal ? "lsp_session_heal_total" : "lsp_session_open_total", heal ? { outcome: "failed" } : { language, outcome: "failed" });
-            return undefined;
-        });
-        sessions.set(language, job);
-        return job;
-    }
-    async open(language, env) {
-        const result = await this.factory(language, env).catch(() => ({ ok: false, reason: "session-open-failed" }));
-        let byLang = this.lastFailure.get(env);
-        if (!result.ok) {
-            if (!byLang) {
-                byLang = new Map();
-                this.lastFailure.set(env, byLang);
-            }
-            byLang.set(language, result.reason);
-            return undefined;
-        }
-        byLang?.delete(language);
-        const transport = result.transport;
-        const readText = async (fp) => {
-            const r = await env.readTextFile(fp);
-            if (!r.ok || r.value === undefined)
-                throw new Error("lsp: read failed");
-            return r.value;
-        };
-        return new TransportLspSession(transport, language, readText, this.log, undefined, this.diagnostics);
-    }
-}
-//# sourceMappingURL=manager.js.map

package/dist/lsp/types.d.ts

@@ -1,12 +0,0 @@
-/**
- * LSP sidecar — service-side types ([ref] §13.1). core 1.82+ ships `createLspTool(manager)`
- * + the `LspServerManager`/`LspSession`/`LspResult` SEAM (`@sema-agent/core`); the runner mounts the tool
- * when OUR manager is wired via `RunnerDeps.lspManager`. We re-export core's seam types — SINGLE SOURCE OF TRUTH,
- * incl. the injectable `LspTransport` (the WS-bridge connection to the language server inside E2B) + `LspReadText`.
- * The protocol LOGIC + the `TransportLspSession` were originally ported FROM core; core later deduplicated them
- * back (session.ts/op-map.ts deleted, byte-equivalence verified). The one thing that stays SERVICE-side is the WS
- * `LspTransport` IMPLEMENTATION (`WsLspTransport` in ws-transport.ts) — core has no WebSocket transport (raw TCP
- * doesn't traverse E2B's HTTP proxy; WS does). "1:1-copy-CC" is the protocol; the WS transport is ours.
- */
-export type { LspOperation, LspRequestParams, LspResult, LspServerManager, LspSession, LspTransport, LspReadText, } from "@sema-agent/core";
-//# sourceMappingURL=types.d.ts.map

package/dist/lsp/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

package/dist/lsp/ws-transport.d.ts

@@ -1,40 +0,0 @@
-import type { LspTransport } from "./types.js";
-/** The slice of `ws`'s WebSocket the transport uses (so tests can supply a fake). */
-export interface WsLike {
-    send(data: string): void;
-    close(): void;
-    on(event: "message" | "close" | "error" | "pong", listener: (arg?: unknown) => void): void;
-    /** WS ping frame (keepalive + liveness probe). Optional — fakes without it get no ping-liveness. */
-    ping?(): void;
-    /** Hard-kill the socket (skip the close handshake) — used when a ping goes unanswered (half-open). */
-    terminate?(): void;
-}
-export declare class WsLspTransport implements LspTransport {
-    private readonly ws;
-    private readonly requestTimeoutMs;
-    private nextId;
-    private readonly pending;
-    private isClosed;
-    private keepalive;
-    private awaitingPong;
-    /** [ref]: server→client NOTIFICATION subscribers (publishDiagnostics etc.). */
-    private readonly notificationHandlers;
-    constructor(ws: WsLike, requestTimeoutMs?: number, keepaliveMs?: number);
-    /** Manager-visible liveness (LspTransport.closed): evict + reopen instead of reusing a dead connection. */
-    get closed(): boolean;
-    private onMessage;
-    private failAll;
-    request(method: string, params: unknown, signal?: AbortSignal): Promise<unknown>;
-    notify(method: string, params: unknown): void;
-    /** [ref] (core 1.220): subscribe to server→client notifications; returns unsubscribe. Additive —
-     *  core's diagnostics registry is the intended consumer; with no subscriber, behavior is byte-identical. */
-    onNotification(handler: (method: string, params: unknown) => void): () => void;
-    close(): Promise<void>;
-}
-/**
- * Connect to a language server's WS bridge inside E2B and run the LSP `initialize`/`initialized` handshake.
- * Returns `undefined` on any failure (→ the manager degrades that language gracefully). `wsUrl` is the
- * `wss://…e2b.dev` URL from `sandbox.getHost(port)`; `rootPath` is the in-sandbox workspace root.
- */
-export declare function connectWsLspTransport(wsUrl: string, rootPath: string, signal?: AbortSignal, initializationOptions?: unknown): Promise<LspTransport | undefined>;
-//# sourceMappingURL=ws-transport.d.ts.map

package/dist/lsp/ws-transport.js

@@ -1,210 +0,0 @@
-import WebSocket from "ws";
-import { pathToUri } from "@sema-agent/core";
-function toError(e) {
-    if (e instanceof Error)
-        return e;
-    const m = e?.message;
-    return new Error(typeof m === "string" && m ? m : String(e));
-}
-export class WsLspTransport {
-    ws;
-    requestTimeoutMs;
-    nextId = 0;
-    pending = new Map();
-    isClosed = false;
-    keepalive;
-    awaitingPong = false;
-    notificationHandlers = new Set();
-    constructor(ws, requestTimeoutMs = 30_000, keepaliveMs = 20_000) {
-        this.ws = ws;
-        this.requestTimeoutMs = requestTimeoutMs;
-        ws.on("message", (data) => this.onMessage(typeof data === "string" ? data : String(data)));
-        ws.on("close", () => this.failAll(new Error("LSP websocket closed")));
-        ws.on("error", (e) => this.failAll(toError(e)));
-        if (keepaliveMs > 0) {
-            ws.on("pong", () => {
-                this.awaitingPong = false;
-            });
-            this.keepalive = setInterval(() => {
-                if (this.awaitingPong) {
-                    this.failAll(new Error("LSP websocket unresponsive (no pong)"));
-                    try {
-                        (ws.terminate ?? ws.close).call(ws);
-                    }
-                    catch {
-                    }
-                    return;
-                }
-                if (typeof ws.ping === "function") {
-                    this.awaitingPong = true;
-                    try {
-                        ws.ping();
-                    }
-                    catch {
-                    }
-                }
-                this.notify("$/keepalive", {});
-            }, keepaliveMs);
-            this.keepalive.unref?.();
-        }
-    }
-    get closed() {
-        return this.isClosed;
-    }
-    onMessage(raw) {
-        let msg;
-        try {
-            msg = JSON.parse(raw);
-        }
-        catch {
-            return;
-        }
-        if (typeof msg.method === "string") {
-            if (msg.id !== undefined && msg.id !== null) {
-                try {
-                    this.ws.send(JSON.stringify({ jsonrpc: "2.0", id: msg.id, error: { code: -32601, message: "method not found" } }));
-                }
-                catch {
-                }
-                return;
-            }
-            const params = msg.params;
-            for (const h of this.notificationHandlers) {
-                try {
-                    h(msg.method, params);
-                }
-                catch {
-                }
-            }
-            return;
-        }
-        if (typeof msg.id === "number") {
-            const p = this.pending.get(msg.id);
-            if (p) {
-                this.pending.delete(msg.id);
-                if (msg.error)
-                    p.reject(new Error(msg.error.message ?? "LSP error"));
-                else
-                    p.resolve(msg.result);
-            }
-        }
-    }
-    failAll(err) {
-        this.isClosed = true;
-        if (this.keepalive)
-            clearInterval(this.keepalive);
-        for (const p of this.pending.values())
-            p.reject(err);
-        this.pending.clear();
-    }
-    request(method, params, signal) {
-        if (this.isClosed)
-            return Promise.reject(new Error("LSP transport closed"));
-        const id = ++this.nextId;
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                if (this.pending.delete(id)) {
-                    signal?.removeEventListener("abort", onAbort);
-                    reject(new Error(`LSP ${method} timed out after ${this.requestTimeoutMs}ms`));
-                }
-            }, this.requestTimeoutMs);
-            const cleanup = () => {
-                clearTimeout(timer);
-                signal?.removeEventListener("abort", onAbort);
-            };
-            const onAbort = () => {
-                if (this.pending.delete(id)) {
-                    cleanup();
-                    reject(new Error(`LSP ${method} aborted`));
-                }
-            };
-            this.pending.set(id, {
-                resolve: (v) => {
-                    cleanup();
-                    resolve(v);
-                },
-                reject: (e) => {
-                    cleanup();
-                    reject(e);
-                },
-            });
-            if (signal) {
-                if (signal.aborted)
-                    return onAbort();
-                signal.addEventListener("abort", onAbort, { once: true });
-            }
-            try {
-                this.ws.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
-            }
-            catch (e) {
-                if (this.pending.delete(id)) {
-                    cleanup();
-                    reject(e instanceof Error ? e : new Error(String(e)));
-                }
-            }
-        });
-    }
-    notify(method, params) {
-        if (this.isClosed)
-            return;
-        try {
-            this.ws.send(JSON.stringify({ jsonrpc: "2.0", method, params }));
-        }
-        catch {
-        }
-    }
-    onNotification(handler) {
-        this.notificationHandlers.add(handler);
-        return () => this.notificationHandlers.delete(handler);
-    }
-    async close() {
-        this.failAll(new Error("LSP transport closed"));
-        try {
-            this.ws.close();
-        }
-        catch {
-        }
-    }
-}
-export async function connectWsLspTransport(wsUrl, rootPath, signal, initializationOptions) {
-    let socket;
-    try {
-        socket = new WebSocket(wsUrl);
-        socket.on("error", () => { });
-        await new Promise((resolve, reject) => {
-            const onAbort = () => reject(new Error("connect aborted"));
-            const settle = (fn) => {
-                signal?.removeEventListener("abort", onAbort);
-                fn();
-            };
-            socket.once("open", () => settle(resolve));
-            socket.once("error", (e) => settle(() => reject(toError(e))));
-            if (signal)
-                signal.addEventListener("abort", onAbort, { once: true });
-        });
-    }
-    catch {
-        try {
-            socket?.close();
-        }
-        catch {
-        }
-        return undefined;
-    }
-    const transport = new WsLspTransport(socket);
-    try {
-        await transport.request("initialize", {
-            processId: null,
-            rootUri: pathToUri(rootPath),
-            capabilities: { textDocument: { definition: {}, references: {}, hover: {}, documentSymbol: {}, implementation: {}, callHierarchy: {} }, workspace: { symbol: {} } },
-            ...(initializationOptions !== undefined ? { initializationOptions } : {}),
-        }, signal);
-        transport.notify("initialized", {});
-        return transport;
-    }
-    catch {
-        await transport.close();
-        return undefined;
-    }
-}
-//# sourceMappingURL=ws-transport.js.map

package/dist/plain-string-record.js

@@ -1,70 +0,0 @@
-import { describeValueShape } from "@sema-agent/settings-schema";
-const PROTO_MEMBER_FAULT = 'no member of a declaration may be named "__proto__"';
-export function readPlainStringRecord(v) {
-    if (v === null || typeof v !== "object" || Array.isArray(v))
-        return { ok: false, fault: v === null ? "got null" : Array.isArray(v) ? "got an array" : `got a ${typeof v}` };
-    const proto = Object.getPrototypeOf(v);
-    if (proto !== Object.prototype && proto !== null)
-        return { ok: false, fault: "got an object that is not plain data (a class instance, a Map, process.env, or a record built on a prototype; copy it into a plain object)" };
-    const record = {};
-    const stripped = [];
-    for (const name of Object.getOwnPropertyNames(v)) {
-        const d = Object.getOwnPropertyDescriptor(v, name);
-        let value;
-        let unreadable = false;
-        try {
-            value = d === undefined ? undefined : Object.hasOwn(d, "value") ? d.value : d.get === undefined ? undefined : Reflect.apply(d.get, v, []);
-        }
-        catch {
-            unreadable = true;
-        }
-        if (unreadable || typeof value !== "string") {
-            const valueFault = unreadable ? "could not be read (its getter threw)" : `must be a string — got ${describeValueShape(value)}`;
-            return { ok: false, fault: name === "__proto__" ? `is not allowed (${PROTO_MEMBER_FAULT}) and its value ${valueFault}` : valueFault, member: name };
-        }
-        if (name === "__proto__")
-            stripped.push({ name, fault: PROTO_MEMBER_FAULT });
-        else
-            record[name] = value;
-    }
-    return { ok: true, record, stripped };
-}
-export function declarationKeys(table) {
-    return Object.freeze(Object.keys(table));
-}
-export function splitDeclaration(declaration, table) {
-    const dispositions = table;
-    const engine = {};
-    let pieces;
-    let seatSeen = false;
-    for (const [key, value] of Object.entries(declaration)) {
-        if (value === undefined)
-            continue;
-        const disposition = Object.hasOwn(dispositions, key) ? dispositions[key] : undefined;
-        switch (disposition) {
-            case "engine":
-                engine[key] = value;
-                break;
-            case "seat": {
-                if (seatSeen)
-                    throw new Error("request declaration: two members are marked as pieces in one disposition table");
-                seatSeen = true;
-                const record = value;
-                if (Object.keys(record).length > 0)
-                    pieces = record;
-                break;
-            }
-            case "withheld":
-                break;
-            case undefined:
-                throw new Error(`request declaration: a member the disposition table does not classify (${JSON.stringify(key.slice(0, 40))})`);
-            default: {
-                const unknownDisposition = disposition;
-                void unknownDisposition;
-                throw new Error("request declaration: a disposition outside the closed set");
-            }
-        }
-    }
-    return { engine: engine, ...(pieces === undefined ? {} : { pieces }) };
-}
-//# sourceMappingURL=plain-string-record.js.map