@sema-agent/server 7.43.0 → 7.44.0

package/dist/lsp/e2b-bridge.js

@@ -1,27 +1,4 @@
-/**
- * The WS↔stdio bridge that runs INSIDE the E2B sandbox + the setup it needs. A language server speaks LSP-JSON-RPC
- * over stdio with **Content-Length** framing; our `WsLspTransport` speaks one raw JSON-RPC message per WS frame.
- * This bridge (started per language server, exposed via `sandbox.getHost(port)`) translates between the two — it's
- * the piece that lets core's stdio-only LSP design work over E2B's HTTP/WS proxy (no stdin on `execStream`).
- *
- * **Proven end-to-end** (scripts/lsp-live-test.ts): `goToDefinition` resolved to the real definition through
- * `wss://…e2b.app`. For production the servers + bridge should be BAKED into an E2B template (the heavy-install
- * pitfall); `lspInstallAndStart` is the on-the-fly path for P1 / un-baked templates.
- */
 import { FRAME_DECODER_JS } from "./lsp-frames.js";
-/**
- * Bridges WS ⇄ a language server's stdio. Server command from `LSP_CMD`, port `LSP_PORT`, and a per-session
- * **auth token** `LSP_TOKEN` (the endpoint is a public `wss://<port>-<id>.e2b.app` URL — the runner connects with
- * `?token=<secret>`; without it, anyone with the URL could read the workspace via LSP, council #4). Frame parsing
- * uses the unit-tested {@link FRAME_DECODER_JS} (council #1/#2/#5).
- *
- * redesign⑤ (#96 §DESIGN-V2 F4): the WS server now rides an explicit `http.createServer` instead of binding its
- * own socket (`new WebSocketServer({host,port})`) — the same port also answers `GET /healthz` (host-side liveness
- * probe, §DESIGN-V2 F2/C6) without a second port or dependency. The EADDRINUSE loud-exit handler MOVES with the
- * bind onto the http server (`server.on('error', …)`, same `lsp-bridge wss error` text + `exit 1` — test/lsp-e2b.test.ts
- * :256-269 pins this exact text/code); `ws` still forwards its underlying server's `'error'` to `wss`, so nothing
- * downstream (per-connection handling) changes.
- */
 export const BRIDGE_SOURCE = FRAME_DECODER_JS +
     String.raw `
 const { WebSocketServer } = require('ws');
@@ -105,45 +82,27 @@ server.listen(PORT, '0.0.0.0', () => {
   console.log('lsp-bridge listening', PORT);
 });
 `;
-/** Bridge dir inside the sandbox(声明提前:tsserver 定值路径引用它)。 */
 export const BRIDGE_DIR = "/home/user/.lsp-bridge";
-/** tls 的 tsserver.js 定值路径(#96 真机门):install 腿保证在场,connect 腿经
- *  `initializationOptions.tsserver.path` 告知 tls(v4 起无 CLI 旗可用)。 */
 export const TSSERVER_JS_PATH = `${BRIDGE_DIR}/node_modules/typescript/lib/tsserver.js`;
-/** Language server command per languageId. P1 = typescript/javascript; dart/kotlin land with their template servers.
- *  `--stdio` only where the server needs it to pick stdio over its other transports (the node-based servers);
- *  gopls/jdtls/kotlin-language-server/sourcekit-lsp/`dart language-server` speak LSP over stdio by default.
- *  #96 真机门发现(E2B 真沙箱逐帧取证,test/lsp-e2b-bridge-live.test.ts):typescript-language-server
- *  **不自动发现全局 typescript**(只认 workspace 内 node_modules/typescript 或显式 tsserver 路径),
- *  `npm i -g … typescript` 装成之后 initialize 仍答 "Could not find a valid TypeScript installation";
- *  且 v4 起 `--tsserver-path` CLI 旗已移除(未知参数=进程退 1,第二轮真机实测)——路径只能走 LSP
- *  `initializationOptions.tsserver.path`(TSSERVER_JS_PATH,connectE2bLspBridge 对 ts/js 传入),
- *  typescript 本体由 lspInstallCommand 落进 BRIDGE_DIR 定值路径(烤好模板文件在场则秒过)。 */
 export const SERVER_CMD = {
     typescript: "typescript-language-server --stdio",
     javascript: "typescript-language-server --stdio",
-    python: "pyright-langserver --stdio", // dev-base bakes pyright
-    go: "gopls", // gopls serves LSP over stdio by default; baked in dev-base (no on-the-fly path — needs the go toolchain)
-    // dev-mobile baked servers (all stdio; no on-the-fly path — they need their SDKs):
-    dart: "dart language-server", // built into the Dart SDK (comes with Flutter)
-    kotlin: "kotlin-language-server", // fwcd candidate; a future bake-off may switch this to JetBrains kotlin-lsp
+    python: "pyright-langserver --stdio",
+    go: "gopls",
+    dart: "dart language-server",
+    kotlin: "kotlin-language-server",
     java: "jdtls",
     swift: "sourcekit-lsp",
 };
-/** npm packages a non-baked sandbox needs (on-the-fly install). Languages absent here (go) REQUIRE a baked template. */
 export const SERVER_NPM = {
     typescript: "typescript-language-server typescript",
     javascript: "typescript-language-server typescript",
     python: "pyright",
 };
-/** One bridge process per language → distinct ports.(BRIDGE_DIR 声明已提前至 SERVER_CMD 上方。) */
 export function portForLanguage(language) {
-    // stable per-language port; extend the table as templates add servers (dev-mobile: dart/kotlin/java/swift)
     const ports = { typescript: 8123, javascript: 8123, dart: 8124, kotlin: 8125, python: 8126, go: 8127, java: 8128, swift: 8129 };
     return ports[language] ?? 8123;
 }
-/** FOREGROUND install (run via `env.exec` — must finish before the start). A baked template makes both checks
- *  skip instantly; a non-baked sandbox npm-installs the server + ws here (slow once per sandbox). */
 export function lspInstallCommand(language) {
     const cmd = SERVER_CMD[language];
     const npm = SERVER_NPM[language];
@@ -151,40 +110,21 @@ export function lspInstallCommand(language) {
         `mkdir -p ${BRIDGE_DIR}`,
         `[ -f ${BRIDGE_DIR}/node_modules/ws/package.json ] || (cd ${BRIDGE_DIR} && echo '{}' > package.json && npm i ws >/tmp/lsp-setup.log 2>&1)`,
         npm ? `command -v ${cmd.split(" ")[0]} >/dev/null || npm i -g ${npm} >>/tmp/lsp-setup.log 2>&1` : "true",
-        // #96 真机门:tls 只认 workspace typescript 或显式 tsserver 路径(全局装了也不认)——把 typescript
-        // 落到 BRIDGE_DIR 定值路径,与 TSSERVER_JS_PATH(initializationOptions 腿)同源。烤好模板文件在场则秒过。
-        // 🔴 钉 @5:裸 `typescript` 现装到 7.x(Go 原生港,lib/ 无 tsserver.js,真机实测)——tls 绑死
-        // TS5 的 JS tsserver。TS7 自带原生 LSP 是未来的换代方向(届时连 tls 一起退役),不是本车。
         npm?.includes("typescript")
             ? `[ -f ${TSSERVER_JS_PATH} ] || (cd ${BRIDGE_DIR} && npm i typescript@5 >>/tmp/lsp-setup.log 2>&1)`
             : "true",
     ].join(" && ");
 }
-/** Start the bridge — run as a TRUE background command (`env.startBackground`), NOT `&`-backgrounded inside a
- *  foreground run: E2B reaps the foreground process group on completion, killing an in-shell `&`/nohup child.
- *  So node is the FOREGROUND here and E2B keeps the background command alive. */
 export function lspStartCommand(language, port, token) {
     return `cd ${BRIDGE_DIR} && LSP_PORT=${port} LSP_TOKEN='${token}' LSP_CMD='${SERVER_CMD[language]}' node bridge.cjs`;
 }
-/** Where the on-the-fly `npm i` output from {@link lspInstallCommand} lands — previously had zero readers
- *  (§DESIGN-V2 F7 bonus fix); an install failure now tails this for the `lastError`/event snippet. */
 export const LSP_SETUP_LOG = "/tmp/lsp-setup.log";
-/** BRIDGE_DIR-relative log the bridge process itself appends to (fatal errors, child exits) — §DESIGN-V2 C4. */
 export function bridgeLogFile() {
     return `${BRIDGE_DIR}/bridge.log`;
 }
-/** Per-port pidfile the bridge writes ONLY after a confirmed bind (BRIDGE_SOURCE's `listen` callback) — see its
- *  header comment for why a losing (EADDRINUSE) second bridge must never clobber this. */
 export function bridgePidFile(port) {
     return `${BRIDGE_DIR}/bridge-${port}.pid`;
 }
-/** §DESIGN-V2 F3: verify a prior bridge generation ACTUALLY stopped before the host mints a replacement.
- *  Exit 0 = confirmed dead (or the pidfile never existed — nothing was ever listening) → safe to start a new
- *  generation on this port. Exit 1 = still alive after the bound wait — the caller MUST NOT start a new bridge:
- *  an unconfirmed kill risks EADDRINUSE (the new generation's fresh token would then be permanently rejected by
- *  the still-listening old process, the token check in BRIDGE_SOURCE) — better to stay `dead` than double-burn
- *  the restart budget on a doomed attempt. POSIX `sh` only (no `seq`/bashisms — sandboxes vary in shell).
- *  Bound: 20 × 0.1s = 2s. */
 export function terminateBridgeCommand(port) {
     const pidfile = bridgePidFile(port);
     return [

package/dist/lsp/e2b-manager.js

@@ -1,20 +1,3 @@
-/**
- * E2B LSP wiring — `createE2bLspManager()` builds the ONE stateless manager (core 1.86.2 seam: core passes
- * the task's env into `sessionFor` at the tool mount point, so there is NO sessionId→env registry and no per-task
- * manager construction; the old registry/monkey-patch wiring is gone).
- *
- * `openE2bLspTransport` does the per-sandbox start: write bridge.cjs from BRIDGE_SOURCE (single source of truth —
- * works on baked + un-baked templates) → foreground install (baked template skips instantly) → start the bridge
- * as a TRUE background command (a shell `&` child gets reaped when E2B completes the foreground command) → WS
- * connect via `wss://getHost(port)?token=…` (per-session auth — the URL is public). It is a single-shot legacy
- * primitive (still used standalone by the k8s wiring test) — NOT part of the bridge resource model below; it
- * carries no generation/dead tracking of its own.
- *
- * redesign⑤ (#96 §DESIGN-V2 A/F3/F6): `createE2bLspManager`'s `transportFactory` owns the actual bridge
- * RESOURCE model — one `E2bBridgeHandle` per env+port, surviving across heals, with a bounded restart budget
- * (`MAX_BRIDGE_GENERATIONS`) so a bridge that crashes (or a first boot that never completes) degrades that
- * language gracefully instead of burning sandbox round-trips forever.
- */
 import { randomUUID } from "node:crypto";
 import { connectWsLspTransport } from "./ws-transport.js";
 import { E2bLspManager } from "./manager.js";
@@ -22,11 +5,6 @@ import { BRIDGE_DIR, BRIDGE_SOURCE, TSSERVER_JS_PATH, LSP_SETUP_LOG, bridgeLogFi
 function describeErr(e) {
     return e instanceof Error ? e.message : String(e);
 }
-/** Best-effort `tail -n <lines> <path>`, capped — used for both the install-failure snippet (§DESIGN-V2 F7,
- *  `LSP_SETUP_LOG` — previously had zero readers) and the connect-exhaustion postmortem (§DESIGN-V2 C5/F9,
- *  `bridge.log`). Returns `undefined` ONLY when the exec itself failed (never observed the log) — an empty
- *  log is still a meaningful (if boring) tail, distinct from "couldn't look." Caps to the LAST `capBytes` —
- *  a giant `Content-Length` framing dump truncated from the FRONT still keeps the most recent (relevant) lines. */
 async function tailLog(env, path, lines = 40, capBytes = 4096) {
     const r = await env.exec(`tail -n ${lines} ${path} 2>/dev/null`).catch(() => undefined);
     if (!r?.ok)
@@ -34,15 +12,9 @@ async function tailLog(env, path, lines = 40, capBytes = 4096) {
     const out = r.value?.stdout ?? "";
     return out.length > capBytes ? out.slice(-capBytes) : out;
 }
-/** §DESIGN-V2 F11: the probe's URL scheme is the WS scheme's HTTP-family counterpart (`wss`'s TLS proxy →
- *  `https`; the k8s pod network's plain `ws` → plain `http` — same "TLS or not" the WS connect itself uses). */
 function httpSchemeFor(scheme) {
     return scheme === "wss" ? "https" : "http";
 }
-/** Real `GET /healthz?token=…` probe (§DESIGN-V2 F2/C6) — 1s bound, `fetch` (no new dependency). Any failure
- *  (no host, network error, non-2xx, timeout) reads as "not confirmed alive"; the caller's decision (skip the
- *  blind retry loop and go straight to the restart arm) only fires once `everConnected` is true (F6) — a cold
- *  first boot never reaches this probe. */
 async function defaultProbeHealthz(env, port, token, scheme) {
     const host = await env.getHost(port);
     if (!host)
@@ -55,15 +27,6 @@ async function defaultProbeHealthz(env, port, token, scheme) {
         return false;
     }
 }
-/** Write bridge.cjs + (foreground) install the language server, then start the bridge as a TRUE background
- *  command. A single-shot primitive: it does NOT check whether a bridge is already listening on `port` — a
- *  caller that can have two languages share one port (`createE2bLspManager`, since `portForLanguage` maps
- *  typescript AND javascript onto 8123 off the same `SERVER_CMD`) MUST call this at most ONCE per env+port
- *  itself. A second `node bridge.cjs` on an already-bound port surfaces as an EADDRINUSE `wss` 'error'
- *  (e2b-bridge.ts D6 hardening keeps that from crashing the sandbox, but the second attempt still fails and
- *  wastes a sandbox round-trip for nothing — HRD-LSP-4). None of the three steps' failures are swallowed
- *  (§DESIGN-V2 F6) — a silently-lost write means `node bridge.cjs` fails at runtime with no signal until
- *  every connect attempt exhausts; reporting it here is strictly faster AND gives a precise reason. */
 async function startE2bBridge(language, env, port, token) {
     const wrote = await env.writeFile(`${BRIDGE_DIR}/bridge.cjs`, BRIDGE_SOURCE).catch((e) => ({ ok: false, error: e }));
     if (!wrote.ok) {
@@ -83,17 +46,11 @@ async function startE2bBridge(language, env, port, token) {
     }
     return { ok: true };
 }
-/** Connect (with retry) to an already-started bridge. Each call opens its OWN WS connection — the bridge spawns
- *  a FRESH child language-server process per connection (e2b-bridge.ts `wss.on('connection', …)`), so two
- *  languages sharing one bridge port each still get an isolated language-server instance. */
 async function connectE2bLspBridge(env, port, token, opts, language) {
     const connect = opts?.connect ?? connectWsLspTransport;
     const retry = opts?.retry ?? { attempts: 6, delayMs: 1500 };
     const root = env.workspaceHandle().mountPath;
-    // #96 真机门:tls(v4 无 CLI 旗)只能经 initializationOptions 拿 tsserver 路径;install 腿已把
-    // typescript 落到 TSSERVER_JS_PATH 定值路径。非 tls 语言不发键(LSP 规范下多余键也会被忽略,但缺席=零风险)。
     const initOptions = language === "typescript" || language === "javascript" ? { tsserver: { path: TSSERVER_JS_PATH } } : undefined;
-    // the bridge starts as a background command → retry the WS connect (with the auth token) while it comes up
     const scheme = opts?.scheme ?? "wss";
     for (let attempt = 0; attempt < retry.attempts; attempt++) {
         const host = await env.getHost(port);
@@ -106,52 +63,29 @@ async function connectE2bLspBridge(env, port, token, opts, language) {
     }
     return undefined;
 }
-/** Start (+ install on a non-baked template) the language server + bridge inside THIS env's sandbox, then connect.
- *  Every call starts (or re-starts) the bridge unconditionally — the one production caller is
- *  `createE2bLspManager`, which de-dupes per env+port before ever reaching here (see its doc). */
 export async function openE2bLspTransport(language, env, opts) {
     if (!SERVER_CMD[language])
-        return undefined; // no server for this language → graceful degrade
+        return undefined;
     const port = portForLanguage(language);
-    const token = opts?.token ?? randomUUID(); // per-session bridge auth — the getHost URL is public (council #4)
+    const token = opts?.token ?? randomUUID();
     const started = await startE2bBridge(language, env, port, token);
     if (!started.ok)
         return undefined;
     return connectE2bLspBridge(env, port, token, opts, language);
 }
-/** A crash-loop must degrade the language, not retry the sandbox forever. 3 covers "an occasional OOM kill";
- *  a bridge that dies again immediately after 3 fresh starts is a standing failure, not a blip. */
 export const MAX_BRIDGE_GENERATIONS = 3;
-/** The single shared `LspServerManager` for the deployment (`RunnerDeps.lspManager`). */
 export function createE2bLspManager(opts) {
-    // One bridge PROCESS + token per env+PORT — not per env+language. `portForLanguage` maps typescript and
-    // javascript onto the SAME port (they share `SERVER_CMD`): keying by language minted two auth tokens for the
-    // one listening bridge (HRD-LSP-4) and re-invoked `startBackground` on an already-bound port on every open.
-    // WeakMap → a destroyed task's bridge bookkeeping is collectible with its env.
     const bridges = new WeakMap();
     const scheme = opts?.scheme ?? "wss";
     const provider = opts?.provider ?? (scheme === "ws" ? "k8s" : "e2b");
     const log = opts?.log ?? (() => { });
     const metrics = opts?.metrics;
     const probe = opts?.probe ?? defaultProbeHealthz;
-    /** The model-facing word for this handle's CURRENT death — `deathReason` unless the restart budget is
-     *  exhausted, in which case "further restarts won't help" supersedes whatever specifically killed the last
-     *  generation. */
     function reasonFor(handle) {
         if (handle.generation >= MAX_BRIDGE_GENERATIONS)
             return "bridge-restart-budget-exhausted";
         return handle.deathReason ?? "bridge-connect-exhausted";
     }
-    /** The ONE place a handle transitions into `dead` — fires the `lsp_bridge_dead_total{reason}` metric +
-     *  `lsp_bridge_dead` event exactly once per transition (§DESIGN-V2 E), using the ALREADY-budget-aware
-     *  reported reason (not the raw `deathReason`) so the metric bucket for a generation that just hit the cap
-     *  reads as "budget exhausted," not as whatever technical failure happened to be the final straw.
-     *  review finding ③ (independent re-review): idempotent — two concurrent callers CAN both conclude the
-     *  SAME still-"ready" handle is dead (e.g. two languages sharing a port each running their own §DESIGN-V2
-     *  F2 healthz probe before either has written `state="dead"`); without this guard the metric/event fired
-     *  once per CALLER instead of once per TRANSITION. A handle already `dead` keeps its ORIGINAL
-     *  deathReason/lastError (the first caller to observe the death is definitionally the one whose diagnostic
-     *  is accurate — a second, redundant observation shouldn't overwrite it). */
     function markDead(handle, reason, detail) {
         if (handle.state === "dead")
             return reasonFor(handle);
@@ -163,9 +97,6 @@ export function createE2bLspManager(opts) {
         log("lsp_bridge_dead", { port: handle.port, generation: handle.generation, reason: reported, detail });
         return reported;
     }
-    /** §DESIGN-V2 C5/F9: best-effort postmortem — tail the bridge's OWN log after a connect exhausts (or the
-     *  probe declares it dead) and before giving up on this generation. Silent on failure (getting the tail is
-     *  itself best-effort; it must never become a SECOND failure mode). */
     async function postmortem(env, port) {
         const tail = await tailLog(env, bridgeLogFile());
         if (tail !== undefined)
@@ -177,9 +108,7 @@ export function createE2bLspManager(opts) {
         hasServerCommand: (language) => Boolean(SERVER_CMD[language]),
         transportFactory: async (language, env) => {
             if (!SERVER_CMD[language])
-                return { ok: false, reason: "no-server-command" }; // mirrors openE2bLspTransport's
-            // own guard; MUST run before touching `bridges` — `portForLanguage` falls back to port 8123 for an
-            // unmapped language, which would otherwise silently borrow typescript's live bridge.
+                return { ok: false, reason: "no-server-command" };
             const port = portForLanguage(language);
             let perPort = bridges.get(env);
             if (!perPort) {
@@ -190,19 +119,7 @@ export function createE2bLspManager(opts) {
             if (!handle || handle.state === "dead") {
                 if (handle && handle.generation >= MAX_BRIDGE_GENERATIONS)
                     return { ok: false, reason: reasonFor(handle) };
-                // review finding ① (independent re-review): the termination-verification (§DESIGN-V2 F3) used to sit
-                // in an `await` HERE, between reading `perPort` above and writing it below — that broke the
-                // run-to-completion dedupe guarantee two languages sharing a port rely on (portForLanguage maps
-                // typescript/javascript onto the SAME port/SERVER_CMD): both could see the same dead handle, both
-                // race past the await, and both mint a COMPETING replacement generation (each calling
-                // startBackground) instead of joining one shared restart. The mint itself — capturing `generation`+
-                // `token` and registering `newHandle` into `perPort` — MUST stay synchronous relative to the
-                // `perPort.get(port)` read above (true again now: "no await above" below). The termination check
-                // moves INSIDE the `ready` chain instead: mint synchronously, verify asynchronously. A SECOND
-                // language arriving while this is in flight now sees `state==="starting"` (not "dead"), skips this
-                // whole branch, and joins the SAME `ready` — exactly the pre-existing dedupe every other caller of
-                // `bridges`/`perPort` already relies on.
-                const priorHandle = handle; // the dying generation (if any) — captured for the async verification below
+                const priorHandle = handle;
                 const generation = handle ? handle.generation + 1 : 1;
                 const token = opts?.token ?? randomUUID();
                 const newHandle = {
@@ -212,15 +129,10 @@ export function createE2bLspManager(opts) {
                     generation,
                     state: "starting",
                     everConnected: false,
-                    ready: Promise.resolve(false), // placeholder — overwritten synchronously below, before any await
+                    ready: Promise.resolve(false),
                 };
                 newHandle.ready = (async () => {
                     if (priorHandle) {
-                        // §DESIGN-V2 F3: verify the OLD generation actually stopped before this one starts — an
-                        // unconfirmed kill risks EADDRINUSE permanently rejecting THIS generation's fresh token (the old
-                        // process is still the one listening). This generation is already minted+registered by the time
-                        // this runs (the dedupe above), so an unconfirmed termination marks IT dead directly rather than
-                        // leaving the prior (already-replaced) handle in the map.
                         const released = await env.exec(terminateBridgeCommand(port)).catch(() => undefined);
                         if (!released?.ok || released.value?.exitCode !== 0) {
                             markDead(newHandle, "bridge-start-failed", "previous generation could not be confirmed stopped — held back from starting to avoid a doomed EADDRINUSE race");
@@ -237,7 +149,7 @@ export function createE2bLspManager(opts) {
                     log("lsp_bridge_start", { port, generation });
                     return true;
                 })();
-                perPort.set(port, newHandle); // synchronous — no await above (run-to-completion dedupe guard RESTORED)
+                perPort.set(port, newHandle);
                 handle = newHandle;
             }
             const started = await handle.ready;

package/dist/lsp/lsp-frames.js

@@ -1,15 +1,3 @@
-/**
- * The LSP stdio Content-Length frame decoder, as JS SOURCE — embedded verbatim into `BRIDGE_SOURCE` (which runs
- * inside the E2B sandbox, can't import TS) AND unit-tested here (test/lsp-frames.test.ts evals this same string).
- * So the in-sandbox parser is actually exercised (council #5: the untestable raw-string parser was the risk).
- *
- * Guards: a frame claiming a non-finite / negative / over-cap length is skipped instead of looping or waiting
- * forever (council #1 defense); the accumulator is dropped if it exceeds the cap with no complete frame (council
- * #2 — a server that never sends `\r\n\r\n`, or a huge Content-Length, can't grow the buffer without bound).
- * The runaway cap carries a `HEADER_SLACK` (core 1.196 #6 twin): a VALID frame whose PAYLOAD passes the
- * `len <= maxBytes` check but whose `Content-Length: <n>\r\n\r\n` header pushes header+payload just over `maxBytes`
- * must NOT be wiped mid-arrival (that silently dropped an in-window legal reply) — so cap at `maxBytes + 128`.
- */
 export const FRAME_DECODER_JS = String.raw `
 function makeFrameDecoder(maxBytes) {
   var HEADER_SLACK = 128; // room for "Content-Length: <n>\r\n\r\n" ON TOP of a max-size payload (core 1.196 #6 twin)

package/dist/lsp/manager.js

@@ -1,18 +1,5 @@
-/**
- * `E2bLspManager` — our `LspServerManager` (core mounts the `lsp` tool over it). STATELESS since core 1.86.2:
- * core passes the task's own ExecutionEnv into `sessionFor(filePath, signal, env)` (prepare-task
- * has the per-task env in scope), so ONE manager serves all tasks; no sessionId→env registry, no per-task
- * construction. Sessions are cached per env+language (a language server is heavy — keep it warm per sandbox)
- * in a WeakMap, so a destroyed task's entries become collectible (its bridge dies with the sandbox).
- *
- * Any miss (no env / unknown language / env without the E2B surface / failed open) → `undefined`, which makes
- * core's tool degrade gracefully to grep/read_file. redesign⑤ (#96 §DESIGN-V2 B/F5/F10): the miss now also comes
- * with a reason (`unavailableReason`, the core 1.86.2+ seam's optional method) — a fixed, model-facing word list
- * (§DESIGN-V2 F7: "reason 词表=模型可见面", short + stable — changing a word IS a behavior change).
- */
 import path from "node:path";
 import { TransportLspSession, LspDiagnosticsRegistry, settleOnAbort } from "@sema-agent/core";
-/** Duck-type check: is this ExecutionEnv an E2B adapter with the LSP surface? */
 export function isLspCapable(env) {
     const e = env;
     return typeof e.getHost === "function" && typeof e.startBackground === "function" && typeof e.workspaceHandle === "function";
@@ -35,32 +22,14 @@ const DEFAULT_EXT_TO_LANG = {
     ".swift": "swift",
     ".rs": "rust",
 };
-/**
- * §DESIGN-V2 F1/F8/F9 —— 本文件曾**手抄**一份 core 的 `settleOnAbort`(注释自陈 core「un-exported」,并写下
- * 「一旦 core 导出即 find-and-delete」的计划)。A-033.1(#256)执行了那句话:core 现已从包根导出它
- * (`index.d.ts:27`,来自 `core/lsp.js`),手抄件遂删除,本文件的两处调用直接消费 core 的实现。
- *
- * 它的语义(读点在 `open` 的两处调用):给**这一个**调用方一个自己的 settle —— 调用方的 `signal` 让它拿到
- * `onAbort()` 的返回,而**共享作业本身不受打扰**(别的调用方可能还等着它)。铁律仍在:绝不能把 signal 穿进
- * 作业里(F9:共享的 open/heal 链不接受 per-caller signal,见 `open` 的文档)。
- */
 export class E2bLspManager {
-    /** Per-sandbox session cache: env (weak) → language → the (self-contained, see `startJob`) shared job. */
     perEnv = new WeakMap();
-    /** §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. */
     lastFailure = new WeakMap();
     factory;
     extToLang;
     log;
     hasServerCommand;
     metrics;
-    /** design/121 (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). */
     diagnostics = new LspDiagnosticsRegistry();
     constructor(opts) {
         this.factory = opts.transportFactory;
@@ -69,13 +38,6 @@ export class E2bLspManager {
         this.hasServerCommand = opts.hasServerCommand ?? (() => true);
         this.metrics = opts.metrics;
     }
-    /**
-     * §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, env) {
         if (!env || !isLspCapable(env))
             return "env-not-lsp-capable";
@@ -88,7 +50,7 @@ export class E2bLspManager {
     }
     async sessionFor(filePath, signal, env) {
         if (!env || !isLspCapable(env))
-            return undefined; // no env passed (core <1.86.2) or not the E2B adapter → degrade
+            return undefined;
         const language = this.extToLang[path.extname(filePath).toLowerCase()];
         if (!language)
             return undefined;
@@ -98,67 +60,27 @@ export class E2bLspManager {
             this.perEnv.set(env, sessions);
         }
         let pending = sessions.get(language) ?? this.startJob(env, sessions, language);
-        // §DESIGN-V2 F9: the shared job never sees a per-caller `signal` — it is a CONTRACT, not an accident, that
-        // the chain below has nothing to wire one into. `settleOnAbort` only bounds how long THIS caller waits for
-        // the (unaffected, still-running-for-everyone-else) shared job — Q16. Wiring a per-caller signal into the
-        // shared chain would let one caller's cancellation abort a session other callers are still waiting on.
         let session = await settleOnAbort(pending, signal, () => undefined);
         if (session?.closed) {
-            // Transport died between tool calls (the E2B proxy idle-kills silent WS connections — live-drill
-            // finding 2026-06-10). Heal: evict + reopen ONCE — the bridge spawns a fresh server per connection.
-            // Carry the dead session's opened files over: a fresh server with no project config only "sees" its
-            // open files, so without the replay cross-file ops silently degrade to single-file (live-repro).
-            // Guard against clobbering a concurrent heal: a racer that lost this race adopts whichever job IS
-            // current in `sessions` (the winner's). `startJob` itself does the `sessions.set` synchronously (no
-            // `await` between creating the job and registering it) — the run-to-completion dedupe guard `startJob`
-            // documents.
             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;
     }
-    /**
-     * §DESIGN-V2 F1 (aligned with core's `NodeLspManager.open`, node-lsp-manager.js :123-153 — 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.
-     */
     startJob(env, sessions, language, heal) {
         const job = this.open(language, env)
             .then(async (session) => {
             if (!session) {
                 if (sessions.get(language) === job)
-                    sessions.delete(language); // don't cache a miss — retry next request
+                    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;
             }
-            // review finding ② (independent re-review): `warmOpen` (unlike `syncOne`'s OWN internal `readText`
-            // guard) can still reject — e.g. `TransportLspSession.syncOne`'s unwrapped `this.transport.notify(...)`
-            // call (core lsp-session.js) — and this is the SHARED job every caller for this env+language awaits;
-            // an uncaught rejection here would otherwise propagate through `job` itself. Aligned with core's own
-            // precedent for this exact call (node-lsp-manager.js:137): the carry-over is best-effort — a failed
-            // resync degrades to "not carried," not an aborted heal.
             if (heal)
                 await session.warmOpen(heal.carry).catch(() => ({ opened: 0, failed: heal.carry.length }));
             if (sessions.get(language) !== job) {
-                // Orphaned: a concurrent heal replaced us in `sessions` before we settled — the winner's session is
-                // what everyone will use; don't leak this one.
                 await session.close().catch(() => undefined);
                 return undefined;
             }
@@ -167,10 +89,6 @@ export class E2bLspManager {
             return session;
         })
             .catch((e) => {
-            // Defense in depth (review finding ②): ANY other unexpected throw in the callback above (not just
-            // warmOpen) must not leave a PERMANENTLY REJECTED promise cached in `sessions` — the self-clean-on-
-            // failure logic above only runs on the resolve-undefined path, never on a rejection, so without this
-            // every subsequent `sessionFor` for this env+language would throw instead of degrading.
             if (sessions.get(language) === job)
                 sessions.delete(language);
             this.log(heal ? "lsp_session_heal_failed" : "lsp_session_open_failed", {
@@ -181,14 +99,10 @@ export class E2bLspManager {
             this.metrics?.inc(heal ? "lsp_session_heal_total" : "lsp_session_open_total", heal ? { outcome: "failed" } : { language, outcome: "failed" });
             return undefined;
         });
-        sessions.set(language, job); // synchronous — no `await` above (run-to-completion dedupe guard)
+        sessions.set(language, job);
         return job;
     }
     async open(language, env) {
-        // "session-open-failed" is the catch-all: the factory threw instead of returning its normal discriminated
-        // result — everything ELSE (install/start/connect/budget failures) is reported through that result, never
-        // through a rejection, so reaching this branch itself is already the diagnostic (the factory's own
-        // implementation is where a specific reason would have been attached).
         const result = await this.factory(language, env).catch(() => ({ ok: false, reason: "session-open-failed" }));
         let byLang = this.lastFailure.get(env);
         if (!result.ok) {
@@ -199,7 +113,7 @@ export class E2bLspManager {
             byLang.set(language, result.reason);
             return undefined;
         }
-        byLang?.delete(language); // F10: a successful open clears any stale reason from a PRIOR failure
+        byLang?.delete(language);
         const transport = result.transport;
         const readText = async (fp) => {
             const r = await env.readTextFile(fp);
@@ -207,12 +121,6 @@ export class E2bLspManager {
                 throw new Error("lsp: read failed");
             return r.value;
         };
-        // core 1.190+ `TransportLspSession` (byte-equivalent to the former local RemoteLspSession — service originally
-        // ported it there; core deduplicated it back, single-source). `undefined` warmup ⇒ core's default {windowMs:10_000,
-        // retryMs:1_000}, identical to the old 4-arg call (equivalence-verified). 6th arg (design/121): the
-        // workspace diagnostics registry — the session subscribes publishDiagnostics via transport.onNotification
-        // (version-staleness guarded core-side); absent onNotification would be a silent no-op, but WsLspTransport
-        // now dispatches.
         return new TransportLspSession(transport, language, readText, this.log, undefined, this.diagnostics);
     }
 }