@sema-agent/server 7.146.0 → 7.148.0

package/dist/lsp/manager.d.ts

@@ -1,129 +0,0 @@
-import { LspDiagnosticsRegistry } from "@sema-agent/core";
-import type { ExecutionEnv } from "@sema-agent/core";
-import type { LspServerManager, LspSession, LspTransport } from "./types.js";
-/** The E2B surface the LSP needs beyond base ExecutionEnv (present on RemoteContainerExecutionEnv).
- *  `exec`'s `stdout` is optional/structural (§DESIGN-V2 F7) — additive to the existing `stderr`-only shape so
- *  the postmortem/install-failure tail reads (`tail -n … <log>`, whose output arrives on stdout) can use the
- *  SAME duck-typed surface without widening what a plain command result MUST carry. */
-export interface LspCapableEnv {
-    exec(command: string): Promise<{
-        ok: boolean;
-        value?: {
-            exitCode: number;
-            stderr: string;
-            stdout?: string;
-        };
-    }>;
-    startBackground(command: string): Promise<void>;
-    writeFile(path: string, content: string): Promise<{
-        ok: boolean;
-    }>;
-    getHost(port: number): Promise<string | undefined>;
-    readTextFile(path: string): Promise<{
-        ok: boolean;
-        value?: string;
-    }>;
-    workspaceHandle(): {
-        mountPath: string;
-    };
-}
-/**
- * §DESIGN-V2 B/F5/F7: the fixed, model-facing failure vocabulary for `unavailableReason`. Three are STATIC
- * (re-derivable synchronously from `filePath`+`env` alone, without ever having attempted an open —
- * `env-not-lsp-capable` / `language-not-mapped` / `no-server-command`); the other five are DYNAMIC (only
- * knowable after an actual open attempt, so they're recorded in `lastFailure` per env+language and read back).
- * Short + stable by design — a model reads these directly (core lsp.js renders `why` straight into the tool's
- * degrade text), so adding/renaming a word is a behavior-facing change, not a refactor.
- */
-export type LspUnavailableReason = "env-not-lsp-capable" | "language-not-mapped" | "no-server-command" | "install-failed" | "bridge-start-failed" | "bridge-connect-exhausted" | "bridge-restart-budget-exhausted" | "session-open-failed";
-/** §DESIGN-V2 F5: the transport factory's discriminated result — replaces the old plain `LspTransport|undefined`
- *  so the bridge-resource owner (e2b-manager's `transportFactory`) can report WHY an attempt failed directly
- *  through its return value, instead of a side channel that could drift from what actually happened. */
-export type LspFactoryResult = {
-    ok: true;
-    transport: LspTransport;
-} | {
-    ok: false;
-    reason: LspUnavailableReason;
-};
-/** Duck-type check: is this ExecutionEnv an E2B adapter with the LSP surface? */
-export declare function isLspCapable(env: ExecutionEnv): env is ExecutionEnv & LspCapableEnv;
-export interface E2bLspManagerOptions {
-    /** Opens (+ `initialize`s) a WS transport to the language server inside THIS env's sandbox. */
-    transportFactory: (language: string, env: LspCapableEnv) => Promise<LspFactoryResult>;
-    /** Override the file-extension → languageId map. */
-    extToLang?: Readonly<Record<string, string>>;
-    /** Observability hook (open/heal/degrade events) — prod wires the service logger; silent when unset. */
-    log?: (event: string, fields: Record<string, unknown>) => void;
-    /** §DESIGN-V2 F5: synchronous re-derivation of the "no-server-command" static reason — owned by the factory
-     *  (e2b-manager's `SERVER_CMD` table), which this generic manager doesn't import. `undefined` (option unset)
-     *  or a `true` return ⇒ a server command IS configured, so a miss (if any) is dynamic (read from
-     *  `lastFailure`) rather than this static one. */
-    hasServerCommand?: (language: string) => boolean;
-    /** §DESIGN-V2 E: `lsp_session_open_total{language,outcome}` / `lsp_session_heal_total{outcome}` — fired at
-     *  the SAME point as the matching `log()` call (event and metric share one source, never drift apart). */
-    metrics?: {
-        inc(name: string, labels?: Record<string, string>): void;
-    };
-}
-/**
- * §DESIGN-V2 F1/F8/F9 —— 本文件曾**手抄**一份 core 的 `settleOnAbort`(注释自陈 core「un-exported」,并写下
- * 「一旦 core 导出即 find-and-delete」的计划)。[ref]([ref])执行了那句话:core 现已从包根导出它
- * (`index.d.ts`,来自 `core/lsp.js`),手抄件遂删除,本文件的两处调用直接消费 core 的实现。
- *
- * 它的语义(读点在 `open` 的两处调用):给**这一个**调用方一个自己的 settle —— 调用方的 `signal` 让它拿到
- * `onAbort()` 的返回,而**共享作业本身不受打扰**(别的调用方可能还等着它)。铁律仍在:绝不能把 signal 穿进
- * 作业里(F9:共享的 open/heal 链不接受 per-caller signal,见 `open` 的文档)。
- */
-export declare class E2bLspManager implements LspServerManager {
-    /** Per-sandbox session cache: env (weak) → language → the (self-contained, see `startJob`) shared job. */
-    private readonly perEnv;
-    /** §DESIGN-V2 B/F10: env (weak) → language → the reason the MOST RECENT open/heal attempt failed. Cleared
-     *  on a successful open (F10) so a stale reason never outlives the failure that produced it. */
-    private readonly lastFailure;
-    private readonly factory;
-    private readonly extToLang;
-    private readonly log;
-    private readonly hasServerCommand;
-    private readonly metrics;
-    /** [ref] (core 1.220, board [S] ①): the workspace diagnostics registry — WORKSPACE-scoped (survives
-     *  heal/evict; diagnostics belong to files, not servers), drained by the Runner at turn boundaries. Every
-     *  session feeds it from `textDocument/publishDiagnostics` (the WS transport now dispatches notifications).
-     *  ⚠️ ONE registry across sandboxes on this manager instance (it is per-deployment) — same posture as
-     *  NodeLspManager's workspace scoping; a task only sees diagnostics for files IT touched (delivered-set +
-     *  fileEdited keying is per-uri, and sandbox workspace paths are per-task-unique). */
-    readonly diagnostics: LspDiagnosticsRegistry;
-    constructor(opts: E2bLspManagerOptions);
-    /**
-     * §DESIGN-V2 B: the core 1.86.2+ seam's optional method — WHY the most recent `sessionFor` miss for this
-     * file happened. Three reasons are STATIC (re-derived here fresh, every call, from `filePath`+`env` alone —
-     * never stored, since they don't need an open attempt to be knowable); the rest are DYNAMIC, read back from
-     * `lastFailure`. `undefined` = this exact (env, language) was never attempted (NOT "available" — a
-     * best-effort postmortem surface, per the seam's own contract).
-     */
-    unavailableReason(filePath: string, env?: ExecutionEnv): LspUnavailableReason | undefined;
-    sessionFor(filePath: string, signal?: AbortSignal, env?: ExecutionEnv): Promise<LspSession | undefined>;
-    /**
-     * §DESIGN-V2 F1 (aligned with core's `NodeLspManager.open`, node-lsp-manager.js `open` — same self-
-     * contained-job shape, not the same code: that manager also tracks a TTL/LRU cache and per-job
-     * `SharedAbortScope`, which this one has no equivalent of per F9). The returned job is SELF-completing:
-     *
-     *  - self-caches: registers itself into `sessions` synchronously BEFORE returning (so a concurrent caller
-     *    in the SAME microtask sees it — no dedupe race);
-     *  - self-cleans: on failure, removes ITSELF from `sessions` (never a newer entry a racer already installed
-     *    — the `sessions.get(language) === job` check) so the next request retries instead of caching a miss;
-     *  - self-warms: a heal job (`heal` set) `warmOpen`s the carried files as part of settling, before anyone
-     *    can observe it as "done" — no caller-side extra step, no window where a racer sees a warm-less session;
-     *  - self-closes an orphan: if a CONCURRENT heal already replaced this job in `sessions` before it settled
-     *    (this job "lost" the race), the just-opened transport is closed instead of leaked with no owner.
-     *
-     *  Callers must NEVER wrap `settleOnAbort` around a naive `await` of a SHARED promise and then branch the
-     *  logging/cache-eviction on THAT wrapped value — a caller whose OWN signal aborted would then look
-     *  indistinguishable from the job itself failing, misfiring `lsp_session_*_failed` and evicting a still-live
-     *  in-flight entry out from under a concurrent caller (§DESIGN-V2 F1). `sessionFor` only ever wraps the
-     *  RETURN boundary; every cache/log decision above happens INSIDE the job, driven by the job's own outcome.
-     */
-    private startJob;
-    private open;
-}
-//# sourceMappingURL=manager.d.ts.map

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