@sema-agent/server 7.147.0 → 7.149.0

package/dist/lsp/e2b-bridge.js

@@ -1,139 +0,0 @@
-import { FRAME_DECODER_JS } from "./lsp-frames.js";
-export const BRIDGE_SOURCE = FRAME_DECODER_JS +
-    String.raw `
-const { WebSocketServer } = require('ws');
-const { spawn } = require('child_process');
-const { URLSearchParams } = require('url');
-const http = require('http');
-const fs = require('fs');
-const PORT = Number(process.env.LSP_PORT || 8123);
-const CMD = (process.env.LSP_CMD || 'typescript-language-server --stdio').split(' ');
-const TOKEN = process.env.LSP_TOKEN || '';
-const MAX = 50 * 1024 * 1024;
-const HEARTBEAT_MS = Number(process.env.LSP_HEARTBEAT_MS || 30000);
-const START_MS = Date.now();
-// Per-port pidfile (BRIDGE_DIR-relative — lspStartCommand cd's there first): the host reads this to verify a
-// prior generation ACTUALLY stopped before minting a replacement (§DESIGN-V2 F3) — an unconfirmed kill risks a
-// new generation's token being permanently rejected by a still-listening old process (the token check below).
-// Written ONLY after a successful bind (inside the listen callback) — a SECOND bridge racing this same port
-// must NOT clobber the FIRST (still listening) bridge's pidfile with its own (about-to-die) pid.
-const PIDFILE = 'bridge-' + PORT + '.pid';
-const LOGFILE = 'bridge.log';
-function logLine(line) { try { fs.appendFileSync(LOGFILE, line + '\n'); } catch {} }
-// Process-fatal hardening (§DESIGN-V2 C1/C2): an uncaught exception/rejection anywhere in this process previously
-// died silently (no stderr line, no log) — the host's only signal was the WS going dead with no explanation.
-process.on('uncaughtException', (err) => { const m = 'lsp-bridge fatal ' + (err && err.message); console.error(m); logLine(m); process.exit(1); });
-process.on('unhandledRejection', (err) => { const m = 'lsp-bridge fatal ' + (err && err.message); console.error(m); logLine(m); process.exit(1); });
-function tokenOf(url) { return new URLSearchParams(((url || '').split('?')[1]) || '').get('token'); }
-const server = http.createServer((req, res) => {
-  const path = ((req && req.url) || '').split('?')[0];
-  if (path === '/healthz') {
-    // Same-origin auth as the WS gate below: TOKEN unset = open (dev/test), TOKEN set + mismatch = 401.
-    if (TOKEN && tokenOf(req.url) !== TOKEN) { res.writeHead(401); res.end(); return; }
-    const body = JSON.stringify({ pid: process.pid, uptimeMs: Date.now() - START_MS, connections: wss.clients.size, generationToken: TOKEN.slice(0, 8) });
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(body);
-    return;
-  }
-  const body = http.STATUS_CODES[426]; // preserves ws's own default "upgrade required" response for any other path
-  res.writeHead(426, { 'Content-Length': Buffer.byteLength(body), 'Content-Type': 'text/plain' });
-  res.end(body);
-});
-// A zero-listener 'error' on ANY EventEmitter throws and crashes the process (Node default). Without this, a
-// bind failure (e.g. EADDRINUSE — a second bridge start racing the same port) took down the WHOLE bridge
-// process, killing every language's LSP session in the sandbox, not just the one that failed to start (HRD-LSP-4).
-// Exit loud + explicit instead of an uncaught-exception dump so the failure is at least attributable.
-server.on('error', (err) => { const m = 'lsp-bridge wss error ' + (err && err.message); console.error(m); logLine(m); process.exit(1); });
-const wss = new WebSocketServer({ server });
-wss.on('connection', (ws, req) => {
-  // Same zero-listener 'error' hazard as wss above, but per-connection: registered FIRST, before anything else
-  // touches this socket. Close (don't crash) — the heartbeat reaper's own ws.terminate() below is a routine
-  // source of a socket 'error' on an already-half-open connection (HRD-LSP-4).
-  ws.on('error', () => { try { ws.terminate(); } catch {} });
-  const q = ((req && req.url) || '').split('?')[1] || '';
-  if (TOKEN && new URLSearchParams(q).get('token') !== TOKEN) { ws.close(); return; } // auth (council #4)
-  ws.isAlive = true;
-  ws.on('pong', () => { ws.isAlive = true; });
-  const child = spawn(CMD[0], CMD.slice(1), { stdio: ['pipe', 'pipe', 'inherit'] });
-  child.stdin.on('error', () => {}); // EPIPE on a write racing the server's exit must not crash the bridge
-  child.on('error', () => { try { ws.close(); } catch {} }); // spawn failure (missing binary) → close, don't crash
-  const decode = makeFrameDecoder(MAX);
-  child.stdout.on('data', (d) => { for (const f of decode(d)) ws.send(f); });
-  ws.on('message', (data) => { const p = Buffer.from(data.toString(), 'utf8'); child.stdin.write('Content-Length: ' + p.length + '\r\n\r\n'); child.stdin.write(p); });
-  // pid guard: the child 'error' handler above routes spawn FAILURES (missing binary — pid never assigned)
-  // through ws.close() → this 'close' handler. Killing a child whose pid was never assigned can signal the
-  // CALLER's process group instead of the (nonexistent) child (HRD-LSP-4; same hazard class as bake-runner's
-  // spawner, src/bake-runner/main.ts).
-  ws.on('close', () => { if (child.pid !== undefined) child.kill(); });
-  child.on('exit', (code, signal) => { logLine('lsp-bridge child exit code=' + code + ' signal=' + signal); try { ws.close(); } catch {} });
-});
-// Reap half-open connections: the E2B proxy kills a WS at ~60-75s and the kill can be SILENT on THIS side too —
-// no close frame, so the per-connection language server above would outlive its dead socket (one leaked server
-// per heal; a long task accumulates them until the sandbox OOMs). terminate() fires 'close' → child.kill().
-setInterval(() => {
-  for (const ws of wss.clients) {
-    if (ws.isAlive === false) { try { ws.terminate(); } catch {} continue; }
-    ws.isAlive = false;
-    try { ws.ping(); } catch {}
-  }
-}, HEARTBEAT_MS);
-server.listen(PORT, '0.0.0.0', () => {
-  try { fs.writeFileSync(PIDFILE, String(process.pid)); } catch (e) { logLine('lsp-bridge pidfile write failed ' + (e && e.message)); }
-  console.log('lsp-bridge listening', PORT);
-});
-`;
-export const BRIDGE_DIR = "/home/user/.lsp-bridge";
-export const TSSERVER_JS_PATH = `${BRIDGE_DIR}/node_modules/typescript/lib/tsserver.js`;
-export const SERVER_CMD = {
-    typescript: "typescript-language-server --stdio",
-    javascript: "typescript-language-server --stdio",
-    python: "pyright-langserver --stdio",
-    go: "gopls",
-    dart: "dart language-server",
-    kotlin: "kotlin-language-server",
-    java: "jdtls",
-    swift: "sourcekit-lsp",
-};
-export const SERVER_NPM = {
-    typescript: "typescript-language-server typescript",
-    javascript: "typescript-language-server typescript",
-    python: "pyright",
-};
-export function portForLanguage(language) {
-    const ports = { typescript: 8123, javascript: 8123, dart: 8124, kotlin: 8125, python: 8126, go: 8127, java: 8128, swift: 8129 };
-    return ports[language] ?? 8123;
-}
-export function lspInstallCommand(language) {
-    const cmd = SERVER_CMD[language];
-    const npm = SERVER_NPM[language];
-    return [
-        `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",
-        npm?.includes("typescript")
-            ? `[ -f ${TSSERVER_JS_PATH} ] || (cd ${BRIDGE_DIR} && npm i typescript@5 >>/tmp/lsp-setup.log 2>&1)`
-            : "true",
-    ].join(" && ");
-}
-export function lspStartCommand(language, port, token) {
-    return `cd ${BRIDGE_DIR} && LSP_PORT=${port} LSP_TOKEN='${token}' LSP_CMD='${SERVER_CMD[language]}' node bridge.cjs`;
-}
-export const LSP_SETUP_LOG = "/tmp/lsp-setup.log";
-export function bridgeLogFile() {
-    return `${BRIDGE_DIR}/bridge.log`;
-}
-export function bridgePidFile(port) {
-    return `${BRIDGE_DIR}/bridge-${port}.pid`;
-}
-export function terminateBridgeCommand(port) {
-    const pidfile = bridgePidFile(port);
-    return [
-        `[ -f ${pidfile} ] || exit 0`,
-        `PID=$(cat ${pidfile})`,
-        `kill "$PID" 2>/dev/null`,
-        `i=0`,
-        `while [ $i -lt 20 ]; do kill -0 "$PID" 2>/dev/null || exit 0; i=$((i+1)); sleep 0.1; done`,
-        `exit 1`,
-    ].join("; ");
-}
-//# sourceMappingURL=e2b-bridge.js.map

package/dist/lsp/e2b-manager.d.ts

@@ -1,93 +0,0 @@
-import { connectWsLspTransport } from "./ws-transport.js";
-import { E2bLspManager, type LspCapableEnv, type LspUnavailableReason } from "./manager.js";
-import type { LspTransport } from "./types.js";
-export interface E2bLspOptions {
-    /** Injectable for tests (no E2B/ws). */
-    connect?: typeof connectWsLspTransport;
-    retry?: {
-        attempts: number;
-        delayMs: number;
-    };
-    /** Bridge auth token override. The manager pins ONE token per env+PORT — the bridge RESOURCE, not the
-     *  language (`portForLanguage` maps several languages, e.g. typescript/javascript, onto the SAME port/process
-     *  — see `createE2bLspManager`). On a RE-open (transport heal after the E2B proxy idle-killed the WS) the
-     *  original bridge process is still listening with the FIRST token — a fresh random token would be rejected
-     *  and the reconnect would always fail. */
-    token?: string;
-    /** WS scheme for the bridge URL. E2B's `getHost` returns a public TLS proxy host → `wss` (default);
-     *  the k8s adapter returns a cluster-internal `podIP:port` → plain `ws` (no TLS on the pod network;
-     *  the per-session bridge token still gates access). */
-    scheme?: "ws" | "wss";
-    /** Observability hook (open/heal/degrade events) — prod wires the service logger. */
-    log?: (event: string, fields: Record<string, unknown>) => void;
-    /** §DESIGN-V2 F11: metrics registry (structural — matches the narrow surface remote-env-e2b.ts's `cfg.metrics`
-     *  already uses). `provider`/`generation`/`reason` labels are filled in by this module, never left freeform. */
-    metrics?: {
-        inc(name: string, labels?: Record<string, string>): void;
-    };
-    /** §DESIGN-V2 F11: the deployment lane feeding this manager (boot/execution-env.ts passes it explicitly —
-     *  "e2b" or "k8s" — rather than this module guessing it back out of `scheme`, which is a WS-protocol detail
-     *  that happens to correlate with the lane but isn't the same axis). Defaults to inferring from `scheme` only
-     *  so existing callers that don't pass it (tests) keep working. */
-    provider?: string;
-    /** §DESIGN-V2 F2/C6: health-probe override for tests (no real sandbox network). Defaults to a real
-     *  `GET /healthz` fetch (1s timeout) — `scheme` maps to the probe's URL scheme, F11 (`wss→https`, `ws→http`). */
-    probe?: (env: LspCapableEnv, port: number, token: string, scheme: "ws" | "wss") => Promise<boolean>;
-}
-/** 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 declare function openE2bLspTransport(language: string, env: LspCapableEnv, opts?: E2bLspOptions): Promise<LspTransport | undefined>;
-/** §DESIGN-V2 A: `starting` while the write+install+startBackground sequence is in flight; `ready` once at
- *  least one WS connect through this generation has succeeded; `dead` once this generation is confirmed (or
- *  presumed, per its own failure) unusable — the ONLY way out of `dead` is minting a new generation. */
-export type BridgeState = "starting" | "ready" | "dead";
-/**
- * §DESIGN-V2 A/F3/F6: one bridge RESOURCE per env+port (not per language — `portForLanguage` maps
- * typescript/javascript onto the SAME port/process off the same `SERVER_CMD`, HRD-LSP-4). A crashed/never-
- * booted bridge can be replaced by minting a new `generation` (bounded by `MAX_BRIDGE_GENERATIONS` — a
- * crash-loop must degrade the language, not burn the sandbox indefinitely); the NEW generation is only ever
- * minted after `terminateBridgeCommand` confirms the OLD one actually stopped (F3) — an unconfirmed kill risks
- * EADDRINUSE permanently rejecting the new generation's fresh token (the old process is still the one
- * listening, and its token check has no way to know a replacement was intended).
- */
-export interface E2bBridgeHandle {
-    readonly port: number;
-    /** Pinned once per generation — the shared bridge resource's auth secret. A per-LANGUAGE token would be
-     *  rejected by the one bridge process actually listening whenever two languages share a port (see the
-     *  module doc's HRD-LSP-4 reference): the second language mints a different token, the bridge only
-     *  recognizes whichever token started it, auth fails, retries exhaust, and that language is permanently
-     *  degraded to grep/read_file for the task. */
-    readonly token: string;
-    /** The `LSP_CMD` this generation's bridge process was launched with — identity documentation (ts/js sharing
-     *  one value/port/process is legitimate, §DESIGN-V2 "不做"); not read back by this module. */
-    readonly serverCmd: string;
-    /** 1 at first mint; +1 every restart. Bounds the restart budget (`MAX_BRIDGE_GENERATIONS`). */
-    readonly generation: number;
-    state: BridgeState;
-    /** The most recent human-readable diagnostic (write/install/start/connect failure, or a probe verdict) —
-     *  feeds `lastError`-style debugging; the MODEL-facing word is `deathReason` (via `unavailableReason`), not
-     *  this free-text string. */
-    lastError?: string;
-    /** The SPECIFIC reason THIS generation died (unset while starting/ready). `unavailableReason`-facing
-     *  reporting overrides this to `bridge-restart-budget-exhausted` once `generation >= MAX_BRIDGE_GENERATIONS`
-     *  — "further restarts won't help" is a different (and, once true, more useful) word than "what killed the
-     *  last one." */
-    deathReason?: LspUnavailableReason;
-    /** True once this generation has completed at least one real WS connect. Gates the fast healthz-probe heal
-     *  path (§DESIGN-V2 F2/F6): a generation that has never connected yet is still cold-starting, not dead —
-     *  treating an unreachable healthz as "dead" during that window would misjudge ordinary boot lag as a crash
-     *  and burn a restart generation for nothing. A generation that HAS connected before, though, really should
-     *  be reachable again quickly, so it skips the blind 6×1500ms retry loop and asks the bridge directly. */
-    everConnected: boolean;
-    /** Resolves once the write+install+startBackground sequence has been ATTEMPTED for this generation — `false`
-     *  (with `state` already flipped to `dead` + `deathReason`/`lastError` set) means it failed before ever
-     *  reaching a connect attempt. */
-    ready: Promise<boolean>;
-}
-/** 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 declare const MAX_BRIDGE_GENERATIONS = 3;
-/** The single shared `LspServerManager` for the deployment (`RunnerDeps.lspManager`). */
-export declare function createE2bLspManager(opts?: E2bLspOptions): E2bLspManager;
-//# sourceMappingURL=e2b-manager.d.ts.map

package/dist/lsp/e2b-manager.js

@@ -1,178 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { connectWsLspTransport } from "./ws-transport.js";
-import { E2bLspManager } from "./manager.js";
-import { BRIDGE_DIR, BRIDGE_SOURCE, TSSERVER_JS_PATH, LSP_SETUP_LOG, bridgeLogFile, lspInstallCommand, lspStartCommand, portForLanguage, SERVER_CMD, terminateBridgeCommand, } from "./e2b-bridge.js";
-function describeErr(e) {
-    return e instanceof Error ? e.message : String(e);
-}
-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)
-        return undefined;
-    const out = r.value?.stdout ?? "";
-    return out.length > capBytes ? out.slice(-capBytes) : out;
-}
-function httpSchemeFor(scheme) {
-    return scheme === "wss" ? "https" : "http";
-}
-async function defaultProbeHealthz(env, port, token, scheme) {
-    const host = await env.getHost(port);
-    if (!host)
-        return false;
-    try {
-        const res = await fetch(`${httpSchemeFor(scheme)}://${host}/healthz?token=${token}`, { signal: AbortSignal.timeout(1000) });
-        return res.ok;
-    }
-    catch {
-        return false;
-    }
-}
-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) {
-        const detail = "error" in wrote && wrote.error !== undefined ? `bridge.cjs write failed: ${describeErr(wrote.error)}` : "bridge.cjs write failed";
-        return { ok: false, reason: "bridge-start-failed", detail };
-    }
-    const installed = await env.exec(lspInstallCommand(language)).catch(() => undefined);
-    if (!installed || !installed.ok || installed.value?.exitCode !== 0) {
-        const snippet = await tailLog(env, LSP_SETUP_LOG);
-        return { ok: false, reason: "install-failed", detail: snippet ? `install failed: ${snippet}` : "install failed (no setup log)" };
-    }
-    try {
-        await env.startBackground(lspStartCommand(language, port, token));
-    }
-    catch (e) {
-        return { ok: false, reason: "bridge-start-failed", detail: `background start failed: ${describeErr(e)}` };
-    }
-    return { ok: true };
-}
-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;
-    const initOptions = language === "typescript" || language === "javascript" ? { tsserver: { path: TSSERVER_JS_PATH } } : undefined;
-    const scheme = opts?.scheme ?? "wss";
-    for (let attempt = 0; attempt < retry.attempts; attempt++) {
-        const host = await env.getHost(port);
-        if (host) {
-            const transport = await connect(`${scheme}://${host}/?token=${token}`, root, undefined, initOptions);
-            if (transport)
-                return transport;
-        }
-        await new Promise((r) => setTimeout(r, retry.delayMs));
-    }
-    return undefined;
-}
-export async function openE2bLspTransport(language, env, opts) {
-    if (!SERVER_CMD[language])
-        return undefined;
-    const port = portForLanguage(language);
-    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);
-}
-export const MAX_BRIDGE_GENERATIONS = 3;
-export function createE2bLspManager(opts) {
-    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;
-    function reasonFor(handle) {
-        if (handle.generation >= MAX_BRIDGE_GENERATIONS)
-            return "bridge-restart-budget-exhausted";
-        return handle.deathReason ?? "bridge-connect-exhausted";
-    }
-    function markDead(handle, reason, detail) {
-        if (handle.state === "dead")
-            return reasonFor(handle);
-        handle.state = "dead";
-        handle.deathReason = reason;
-        handle.lastError = detail;
-        const reported = reasonFor(handle);
-        metrics?.inc("lsp_bridge_dead_total", { reason: reported });
-        log("lsp_bridge_dead", { port: handle.port, generation: handle.generation, reason: reported, detail });
-        return reported;
-    }
-    async function postmortem(env, port) {
-        const tail = await tailLog(env, bridgeLogFile());
-        if (tail !== undefined)
-            log("lsp_bridge_postmortem", { port, tail });
-    }
-    return new E2bLspManager({
-        log: opts?.log,
-        metrics,
-        hasServerCommand: (language) => Boolean(SERVER_CMD[language]),
-        transportFactory: async (language, env) => {
-            if (!SERVER_CMD[language])
-                return { ok: false, reason: "no-server-command" };
-            const port = portForLanguage(language);
-            let perPort = bridges.get(env);
-            if (!perPort) {
-                perPort = new Map();
-                bridges.set(env, perPort);
-            }
-            let handle = perPort.get(port);
-            if (!handle || handle.state === "dead") {
-                if (handle && handle.generation >= MAX_BRIDGE_GENERATIONS)
-                    return { ok: false, reason: reasonFor(handle) };
-                const priorHandle = handle;
-                const generation = handle ? handle.generation + 1 : 1;
-                const token = opts?.token ?? randomUUID();
-                const newHandle = {
-                    port,
-                    token,
-                    serverCmd: SERVER_CMD[language],
-                    generation,
-                    state: "starting",
-                    everConnected: false,
-                    ready: Promise.resolve(false),
-                };
-                newHandle.ready = (async () => {
-                    if (priorHandle) {
-                        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");
-                            log("lsp_bridge_restart_blocked", { port, generation });
-                            return false;
-                        }
-                    }
-                    const started = await startE2bBridge(language, env, port, token);
-                    if (!started.ok) {
-                        markDead(newHandle, started.reason ?? "bridge-start-failed", started.detail ?? "bridge start failed");
-                        return false;
-                    }
-                    metrics?.inc("lsp_bridge_start_total", { provider, generation: String(generation) });
-                    log("lsp_bridge_start", { port, generation });
-                    return true;
-                })();
-                perPort.set(port, newHandle);
-                handle = newHandle;
-            }
-            const started = await handle.ready;
-            if (!started)
-                return { ok: false, reason: reasonFor(handle) };
-            if (handle.everConnected) {
-                const alive = await probe(env, handle.port, handle.token, scheme);
-                if (!alive) {
-                    const reason = markDead(handle, "bridge-connect-exhausted", "healthz probe reported the bridge unreachable");
-                    await postmortem(env, port);
-                    return { ok: false, reason };
-                }
-            }
-            const transport = await connectE2bLspBridge(env, handle.port, handle.token, opts, language);
-            if (!transport) {
-                const reason = markDead(handle, "bridge-connect-exhausted", "bridge connect exhausted after all retries");
-                await postmortem(env, port);
-                return { ok: false, reason };
-            }
-            handle.everConnected = true;
-            handle.state = "ready";
-            return { ok: true, transport };
-        },
-    });
-}
-//# sourceMappingURL=e2b-manager.js.map

package/dist/lsp/lsp-frames.d.ts

@@ -1,14 +0,0 @@
-/**
- * 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 declare const FRAME_DECODER_JS: string;
-//# sourceMappingURL=lsp-frames.d.ts.map

package/dist/lsp/lsp-frames.js

@@ -1,25 +0,0 @@
-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)
-  let buf = Buffer.alloc(0);
-  return function decode(chunk) {
-    const frames = [];
-    buf = Buffer.concat([buf, chunk]);
-    if (buf.length > maxBytes + HEADER_SLACK) buf = Buffer.alloc(0); // runaway / no delimiter → drop (council #2); +slack so a valid frame isn't wiped when its header pushes total past maxBytes (core #6)
-    for (;;) {
-      const he = buf.indexOf('\r\n\r\n');
-      if (he === -1) break;
-      const m = /Content-Length:\s*(\d+)/i.exec(buf.slice(0, he).toString('ascii'));
-      if (!m) { buf = buf.slice(he + 4); continue; }
-      const len = Number(m[1]);
-      if (!Number.isFinite(len) || len < 0 || len > maxBytes) { buf = buf.slice(he + 4); continue; } // skip bad frame (council #1/#2)
-      const start = he + 4;
-      if (buf.length < start + len) break; // wait for the rest of this frame
-      frames.push(buf.slice(start, start + len).toString('utf8'));
-      buf = buf.slice(start + len);
-    }
-    return frames;
-  };
-}
-`;
-//# sourceMappingURL=lsp-frames.js.map

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