@sema-agent/server 7.43.0 → 7.44.0

package/dist/lsp/ws-transport.js

@@ -1,14 +1,5 @@
-/**
- * `WsLspTransport` — LSP JSON-RPC over a WebSocket to the language server inside the E2B sandbox (the bridge
- * exposed via `sandbox.getHost(port)`). Each WS message is one JSON-RPC message (the LSP-over-WebSocket
- * convention — no Content-Length framing needed; that's the part that differs from CC's stdio transport). The
- * socket is behind a minimal `WsLike` interface so the request/response correlation is unit-testable without a
- * network; `connectWsLspTransport` wires the real `ws` client + the `initialize` handshake.
- */
 import WebSocket from "ws";
 import { pathToUri } from "@sema-agent/core";
-/** Error-or-event → Error. Bun's ws shim emits browser-style ErrorEvents (NOT instanceof Error) whose
- *  String() is "[object ErrorEvent]" — extract .message so real failures (e.g. TLS) stay readable. */
 function toError(e) {
     if (e instanceof Error)
         return e;
@@ -23,7 +14,6 @@ export class WsLspTransport {
     isClosed = false;
     keepalive;
     awaitingPong = false;
-    /** design/121: server→client NOTIFICATION subscribers (publishDiagnostics etc.). */
     notificationHandlers = new Set();
     constructor(ws, requestTimeoutMs = 30_000, keepaliveMs = 20_000) {
         this.ws = ws;
@@ -31,27 +21,17 @@ export class WsLspTransport {
         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)));
-        // Keepalive + LIVENESS: the E2B ingress kills a WS after ~60-75s regardless of traffic (live-tested:
-        // neither ws pings nor app-level data frames prevent it), and the kill can be SILENT — no close frame
-        // reaches us, the socket goes half-open, requests black-hole into the 30s timeout and `closed` never
-        // flips, so the manager keeps reusing a dead session (live-drill: "first op after a thinking gap is
-        // none, the next op heals"). So the ping doubles as a liveness probe: a ping with no pong by the next
-        // interval ⇒ half-open ⇒ fail everything locally + terminate, flipping `closed` so the manager heals
-        // on the very next tool call. `$/keepalive` (LSP spec: `$/` notifications must be ignored) stays as a
-        // best-effort data-frame keepalive for other backends.
         if (keepaliveMs > 0) {
             ws.on("pong", () => {
                 this.awaitingPong = false;
             });
             this.keepalive = setInterval(() => {
                 if (this.awaitingPong) {
-                    // previous ping unanswered for a full interval → half-open connection
                     this.failAll(new Error("LSP websocket unresponsive (no pong)"));
                     try {
                         (ws.terminate ?? ws.close).call(ws);
                     }
                     catch {
-                        /* already gone */
                     }
                     return;
                 }
@@ -61,7 +41,6 @@ export class WsLspTransport {
                         ws.ping();
                     }
                     catch {
-                        /* socket gone — close/error handler does the bookkeeping */
                     }
                 }
                 this.notify("$/keepalive", {});
@@ -69,7 +48,6 @@ export class WsLspTransport {
             this.keepalive.unref?.();
         }
     }
-    /** Manager-visible liveness (LspTransport.closed): evict + reopen instead of reusing a dead connection. */
     get closed() {
         return this.isClosed;
     }
@@ -79,40 +57,28 @@ export class WsLspTransport {
             msg = JSON.parse(raw);
         }
         catch {
-            return; // not JSON — ignore
+            return;
         }
-        // 🔴 A server→client message (has `method`) is a REQUEST (also carries `id`) or a NOTIFICATION (no `id`) — NEVER a
-        // response to us (a JSON-RPC response has no `method`). Handle it FIRST + by `method`, not by `id`:
-        // otherwise a server REQUEST whose `id` (the SERVER's id space) COLLIDES with one of OUR pending request ids would
-        // be `this.pending.get(id)` → resolve OUR request with the server's request as if it were our response = a silent
-        // wrong answer. We implement NO server→client method → reply `-32601 MethodNotFound` to a REQUEST so the server does
-        // not hang waiting (some servers send `workspace/configuration` etc. and block until answered); ignore a NOTIFICATION.
         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 {
-                    /* best-effort — a dead socket fails the pending requests elsewhere */
                 }
-                return; // an answered server REQUEST — never our response, never a notification
+                return;
             }
-            // design/121 (core 1.220 LspTransport.onNotification): a server NOTIFICATION (method, no id) —
-            // publishDiagnostics etc. — now dispatches to subscribers (previously dropped). Contract: swallow a
-            // throwing handler (a bad consumer must never kill the WS read loop). Zero subscribers = old behavior.
             const params = msg.params;
             for (const h of this.notificationHandlers) {
                 try {
                     h(msg.method, params);
                 }
                 catch {
-                    /* per-contract: never let a consumer kill the read loop */
                 }
             }
             return;
         }
         if (typeof msg.id === "number") {
-            // A RESPONSE to one of our requests (no `method` ⇒ a server-request id can no longer hijack a pending entry).
             const p = this.pending.get(msg.id);
             if (p) {
                 this.pending.delete(msg.id);
@@ -138,7 +104,7 @@ export class WsLspTransport {
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 if (this.pending.delete(id)) {
-                    signal?.removeEventListener("abort", onAbort); // or a long-lived task signal accumulates one listener per timeout
+                    signal?.removeEventListener("abort", onAbort);
                     reject(new Error(`LSP ${method} timed out after ${this.requestTimeoutMs}ms`));
                 }
             }, this.requestTimeoutMs);
@@ -185,11 +151,8 @@ export class WsLspTransport {
             this.ws.send(JSON.stringify({ jsonrpc: "2.0", method, params }));
         }
         catch {
-            /* fire-and-forget */
         }
     }
-    /** design/121 (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) {
         this.notificationHandlers.add(handler);
         return () => this.notificationHandlers.delete(handler);
@@ -200,28 +163,18 @@ export class WsLspTransport {
             this.ws.close();
         }
         catch {
-            /* noop */
         }
     }
 }
-/**
- * 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 async function connectWsLspTransport(wsUrl, rootPath, signal, initializationOptions) {
     let socket;
     try {
         socket = new WebSocket(wsUrl);
-        // Permanent no-op 'error' listener FIRST: Bun's ws shim can emit 'error' again after the once-handler
-        // below consumed the first one (e.g. a late emission while closing a failed socket). An 'error' event
-        // with zero listeners throws and KILLS the process — a bridge-still-booting connect retry crashed the
-        // whole worker in the 2026-06-11 night drill. Control flow still goes through the once-handlers.
         socket.on("error", () => { });
         await new Promise((resolve, reject) => {
             const onAbort = () => reject(new Error("connect aborted"));
             const settle = (fn) => {
-                signal?.removeEventListener("abort", onAbort); // don't accumulate listeners on a long-lived task signal
+                signal?.removeEventListener("abort", onAbort);
                 fn();
             };
             socket.once("open", () => settle(resolve));
@@ -232,10 +185,9 @@ export async function connectWsLspTransport(wsUrl, rootPath, signal, initializat
     }
     catch {
         try {
-            socket?.close(); // an aborted connect leaves the socket mid-handshake — don't leak it (it WOULD open)
+            socket?.close();
         }
         catch {
-            /* never opened */
         }
         return undefined;
     }
@@ -245,8 +197,6 @@ export async function connectWsLspTransport(wsUrl, rootPath, signal, initializat
             processId: null,
             rootUri: pathToUri(rootPath),
             capabilities: { textDocument: { definition: {}, references: {}, hover: {}, documentSymbol: {}, implementation: {}, callHierarchy: {} }, workspace: { symbol: {} } },
-            // #96 真机门:tls 的 tsserver 路径只能走这里(v4 移除了 CLI 旗);非 tls 服务器按 LSP 规范忽略
-            // 未知 initializationOptions。缺席时不发键(老行为逐字保持)。
             ...(initializationOptions !== undefined ? { initializationOptions } : {}),
         }, signal);
         transport.notify("initialized", {});

package/dist/lsp-evict.js

@@ -1,17 +1,3 @@
-/**
- * core 1.191 LSP eviction — the host-lane task-end cleanup wrap, factored out of main.ts so it is unit-testable.
- *
- * Decorate an EPHEMERAL host `ExecutionEnv` so its `destroy()` (task-end, which `rm -rf`s the per-task
- * `sema-host-<id>` workspace) ALSO evicts the cached LSP servers rooted at that workspace — so a busy host server
- * doesn't retain one heavy language server (jdtls = a whole JVM) per (task × language) until process shutdown.
- * `evict` is best-effort + idempotent + fire-and-forget so it NEVER blocks or breaks teardown; the server dies async
- * while the dir is rm'd (rooted there, it just sees ENOENT). Only the ephemeral lane is wrapped by the caller — the
- * cwdHonored persistent-project path keeps its warm server (stable root, reused across turns = CC-parity, no leak).
- *
- * Structural param types (no `ExecutionEnv`/`NodeLspManager` import): a non-evicting manager (e2b/k8s bridge) or an
- * env without a string `cwd` / callable `destroy` is returned UNWRAPPED (probe-guarded), so this is a safe no-op
- * everywhere the precondition doesn't hold.
- */
 export function evictLspOnDestroy(env, lsp) {
     const evict = lsp?.evict;
     const e = env;
@@ -20,7 +6,7 @@ export function evictLspOnDestroy(env, lsp) {
     const origDestroy = e.destroy.bind(e);
     const root = e.cwd;
     e.destroy = () => {
-        void evict.call(lsp, root).catch(() => { }); // fire-and-forget: never block/break teardown on a slow server close
+        void evict.call(lsp, root).catch(() => { });
         return origDestroy();
     };
     return env;