@sema-agent/core 1.451.0 → 2.0.0

package/dist/engine/execution-env/node-execution-env.js

@@ -1,14 +1,14 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { closeSync, constants, createReadStream, mkdtempSync, openSync, readSync, statSync, truncateSync, unlinkSync } from "node:fs";
-import { access, appendFile, lstat, mkdir, mkdtemp, readdir, readFile, readlink, realpath, rm, writeFile, } from "node:fs/promises";
+import { access, appendFile, lstat, mkdir, mkdtemp, open, readdir, readFile, readlink, realpath, rename, rm, unlink, writeFile, } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { ExecutionError, err, FileError, ok, toError, } from "../harness/types.js";
 import { killProcessTree, shutdownDebug } from "./kill-tree.js";
 import { scrubSecretEnv } from "../../core/secret-env.js";
-import { RollingTailBuffer, markTruncated } from "../../core/exec-output-tail.js";
+import { RollingTailBuffer, markLiveSpoolRotations, markTruncated, newStreamCursorState, sliceStreamIncrement, } from "../../core/exec-output-tail.js";
 import { BackgroundShellError } from "../../core/background-shell.js";
 import { SchedulerError } from "../../core/scheduler.js";
 const MAX_TIMER_TIMEOUT_MS = 2_147_000_000;
@@ -88,6 +88,11 @@ function toFileError(error, path) {
 function abortResult(signal, path) {
     return signal?.aborted ? err(new FileError("aborted", "aborted", path)) : undefined;
 }
+function isFsSupportError(error) {
+    const code = isNodeError(error) ? error.code : undefined;
+    return code === "EINVAL" || code === "ENOTSUP" || code === "EPERM" || code === "ENOSYS";
+}
+const RENAME_FALLBACK_CODES = new Set(["EXDEV", "EPERM", "EEXIST", "EBUSY"]);
 async function pathExists(path) {
     try {
         await access(path, constants.F_OK);
@@ -208,6 +213,23 @@ const EXEC_SPOOL_PUMP_MS = 200;
 const EXEC_SPOOL_ROTATE_BYTES = 8 * 1024 * 1024;
 const EXEC_SPOOL_FINAL_TAIL_BYTES = 8 * 1024 * 1024;
 const EXEC_SPOOL_HARD_CAP_BYTES = 16 * 1024 * 1024;
+export function decideSpoolReclaim(args) {
+    const rotate = args.rotateBytes ?? EXEC_SPOOL_ROTATE_BYTES;
+    const hardCap = args.hardCapBytes ?? EXEC_SPOOL_HARD_CAP_BYTES;
+    if (args.cursor < rotate)
+        return { reclaim: false };
+    if (args.size === args.cursor) {
+        if (!args.writerLive)
+            return { reclaim: true, live: false, skippedBytes: 0 };
+        if (args.size >= hardCap)
+            return { reclaim: true, live: true, skippedBytes: 0 };
+        return { reclaim: false };
+    }
+    if (args.size > args.cursor && args.size >= hardCap) {
+        return { reclaim: true, live: args.writerLive, skippedBytes: args.size - args.cursor };
+    }
+    return { reclaim: false };
+}
 const SIGNUM = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGABRT: 6, SIGKILL: 9, SIGSEGV: 11, SIGPIPE: 13, SIGTERM: 15 };
 export function openSpoolPair(base) {
     const outPath = `${base}.out.log`;
@@ -308,6 +330,9 @@ export class NodeExecutionEnv {
             const adoptOnTimeoutRef = {};
             const pumpSpoolRef = {};
             const drainSpoolRef = {};
+            const liveRotations = { out: 0, err: 0 };
+            const liveRotationsTotal = () => liveRotations.out + liveRotations.err;
+            const writerLive = () => !settled && child !== undefined && child.exitCode === null && child.signalCode === null;
             const armForceSettle = (result) => {
                 if (forceSettleRef.current || settled)
                     return;
@@ -326,7 +351,7 @@ export class NodeExecutionEnv {
                 drainSpoolRef.current?.();
                 const so = stdoutTail.result();
                 const se = stderrTail.result();
-                return { stdout: markTruncated(so.text, so.droppedBytes), stderr: markTruncated(se.text, se.droppedBytes) };
+                return { stdout: markTruncated(so.text, so.droppedBytes), stderr: markLiveSpoolRotations(markTruncated(se.text, se.droppedBytes), liveRotationsTotal()) };
             };
             const onAbort = () => {
                 abortKillInFlight = true;
@@ -515,16 +540,15 @@ export class NodeExecutionEnv {
                 if (spoolCursor[lane.cursor] < EXEC_SPOOL_ROTATE_BYTES)
                     return;
                 try {
-                    const size = statSync(lane.path).size;
-                    if (size === spoolCursor[lane.cursor]) {
-                        truncateSync(lane.path, 0);
-                        spoolCursor[lane.cursor] = 0;
-                    }
-                    else if (size >= EXEC_SPOOL_HARD_CAP_BYTES) {
-                        lane.tail.recordSkippedBytes(size - spoolCursor[lane.cursor]);
-                        truncateSync(lane.path, 0);
-                        spoolCursor[lane.cursor] = 0;
-                    }
+                    const d = decideSpoolReclaim({ size: statSync(lane.path).size, cursor: spoolCursor[lane.cursor], writerLive: writerLive() });
+                    if (!d.reclaim)
+                        return;
+                    if (d.skippedBytes > 0)
+                        lane.tail.recordSkippedBytes(d.skippedBytes);
+                    if (d.live)
+                        liveRotations[lane.cursor]++;
+                    truncateSync(lane.path, 0);
+                    spoolCursor[lane.cursor] = 0;
                 }
                 catch {
                 }
@@ -559,7 +583,9 @@ export class NodeExecutionEnv {
                 if (settled || !child)
                     return false;
                 pumpSpoolRef.current?.();
-                const shellId = this.adoptRunningChild(child, stdoutTail.result(), stderrTail.result(), execSpoolRef.current !== undefined ? { spool: execSpoolRef.current, cursors: { out: spoolCursor.out, err: spoolCursor.err } } : undefined);
+                const shellId = this.adoptRunningChild(child, stdoutTail.result(), stderrTail.result(), execSpoolRef.current !== undefined
+                    ? { spool: execSpoolRef.current, cursors: { out: spoolCursor.out, err: spoolCursor.err }, liveRotations: liveRotationsTotal() }
+                    : undefined);
                 if (shellId === undefined)
                     return false;
                 if (spoolPumpRef.current)
@@ -652,12 +678,12 @@ export class NodeExecutionEnv {
                     const signum = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGABRT: 6, SIGKILL: 9, SIGSEGV: 11, SIGPIPE: 13, SIGTERM: 15 };
                     settle(ok({
                         stdout: markTruncated(so.text, so.droppedBytes),
-                        stderr: `${markTruncated(se.text, se.droppedBytes)}${se.text.endsWith("\n") || se.text === "" ? "" : "\n"}[process terminated by ${signal}]`,
+                        stderr: markLiveSpoolRotations(`${markTruncated(se.text, se.droppedBytes)}${se.text.endsWith("\n") || se.text === "" ? "" : "\n"}[process terminated by ${signal}]`, liveRotationsTotal()),
                         exitCode: 128 + (signum[signal] ?? 9),
                     }));
                     return;
                 }
-                settle(ok({ stdout: markTruncated(so.text, so.droppedBytes), stderr: markTruncated(se.text, se.droppedBytes), exitCode: code ?? 0 }));
+                settle(ok({ stdout: markTruncated(so.text, so.droppedBytes), stderr: markLiveSpoolRotations(markTruncated(se.text, se.droppedBytes), liveRotationsTotal()), exitCode: code ?? 0 }));
             };
             child.on("close", (code, signal) => settleFromTermination(code, signal));
             child.on("exit", (code, signal) => {
@@ -744,10 +770,116 @@ export class NodeExecutionEnv {
         }
         try {
             await mkdir(resolve(resolved, ".."), { recursive: true });
-            const afterMkdirAbort = abortResult(abortSignal, resolved);
-            if (afterMkdirAbort) {
-                return afterMkdirAbort;
+        }
+        catch (error) {
+            return err(toFileError(error, resolved));
+        }
+        const afterMkdirAbort = abortResult(abortSignal, resolved);
+        if (afterMkdirAbort) {
+            return afterMkdirAbort;
+        }
+        let target = resolved;
+        let existingMode;
+        let st;
+        try {
+            st = await lstat(resolved);
+        }
+        catch {
+            st = undefined;
+        }
+        if (st !== undefined) {
+            if (st.isSymbolicLink()) {
+                let hop;
+                try {
+                    const link = await readlink(resolved);
+                    const parentReal = await realpath(resolve(resolved, "..")).catch(() => resolve(resolved, ".."));
+                    hop = isAbsolute(link) ? link : resolve(parentReal, link);
+                }
+                catch {
+                    hop = undefined;
+                }
+                if (hop === undefined)
+                    return await this.writeFileInPlace(resolved, content, abortSignal);
+                let hopStat;
+                try {
+                    hopStat = await lstat(hop);
+                }
+                catch {
+                    hopStat = undefined;
+                }
+                if (hopStat !== undefined && !hopStat.isFile()) {
+                    return await this.writeFileInPlace(resolved, content, abortSignal);
+                }
+                target = hop;
+                existingMode = hopStat !== undefined ? hopStat.mode & 0o7777 : undefined;
+            }
+            else if (!st.isFile()) {
+                return await this.writeFileInPlace(resolved, content, abortSignal);
             }
+            else {
+                existingMode = st.mode & 0o7777;
+            }
+        }
+        const tmp = `${target}.tmp.${process.pid}.${randomUUID().replace(/-/g, "").slice(0, 12)}`;
+        let tmpDurable = false;
+        try {
+            const handle = await open(tmp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0));
+            try {
+                await handle.writeFile(content, { signal: abortSignal });
+                if (existingMode !== undefined) {
+                    try {
+                        await handle.chmod(existingMode);
+                    }
+                    catch (error) {
+                        if (!isFsSupportError(error))
+                            throw error;
+                    }
+                }
+                try {
+                    await handle.sync();
+                }
+                catch (error) {
+                    if (!isFsSupportError(error))
+                        throw error;
+                }
+                tmpDurable = true;
+            }
+            finally {
+                await handle.close().catch(() => { });
+            }
+        }
+        catch (error) {
+            await unlink(tmp).catch(() => { });
+            if (isNodeError(error) && error.code === "EACCES" && existingMode !== undefined) {
+                return await this.writeFileInPlace(resolved, content, abortSignal);
+            }
+            return err(toFileError(error, resolved));
+        }
+        const preRenameAbort = abortResult(abortSignal, resolved);
+        if (preRenameAbort) {
+            await unlink(tmp).catch(() => { });
+            return preRenameAbort;
+        }
+        try {
+            await rename(tmp, target);
+            return ok(undefined);
+        }
+        catch (error) {
+            const code = isNodeError(error) ? error.code : undefined;
+            if (tmpDurable && code !== undefined && RENAME_FALLBACK_CODES.has(code)) {
+                const inPlace = await this.writeFileInPlace(resolved, content, abortSignal);
+                if (inPlace.ok) {
+                    await unlink(tmp).catch(() => { });
+                    return inPlace;
+                }
+                return err(new FileError("unknown", `write to ${resolved} failed after the atomic rename was refused (${code}): ${inPlace.error.message}. The new content was preserved at ${tmp}`, resolved, inPlace.error));
+            }
+            await unlink(tmp).catch(() => { });
+            return err(toFileError(error, resolved));
+        }
+    }
+    async writeFileInPlace(resolved, content, abortSignal) {
+        try {
             await writeFile(resolved, content, { signal: abortSignal });
             return ok(undefined);
         }
@@ -913,12 +1045,13 @@ export class NodeExecutionEnv {
         const shellId = `bg_${++this.bgCounter}_${randomUUID()}`;
         const entry = {
             child,
-            stdout: { tail: new RollingTailBuffer(), totalBytes: 0, cursorBytes: 0 },
-            stderr: { tail: new RollingTailBuffer(), totalBytes: 0, cursorBytes: 0 },
+            stdout: { ...newStreamCursorState(), totalBytes: 0 },
+            stderr: { ...newStreamCursorState(), totalBytes: 0 },
             status: "running",
             ...(handover !== undefined
                 ? { spool: { outPath: handover.spool.outPath, errPath: handover.spool.errPath, fileCursor: { ...handover.cursors }, ephemeral: true } }
                 : {}),
+            ...(handover !== undefined && (handover.liveRotations ?? 0) > 0 ? { liveRotations: handover.liveRotations } : {}),
         };
         const seedOut = Buffer.from(stdoutSoFar.text, "utf8");
         const seedErr = Buffer.from(stderrSoFar.text, "utf8");
@@ -928,15 +1061,19 @@ export class NodeExecutionEnv {
         entry.stderr.tail.push(seedErr);
         entry.stdout.totalBytes += stdoutSoFar.droppedBytes + seedOut.length;
         entry.stderr.totalBytes += stderrSoFar.droppedBytes + seedErr.length;
+        entry.stdout.acceptedBytes += seedOut.length;
+        entry.stderr.acceptedBytes += seedErr.length;
         child.stdout?.on("data", (chunk) => {
             const buf = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
             entry.stdout.tail.push(buf);
             entry.stdout.totalBytes += buf.length;
+            entry.stdout.acceptedBytes += buf.length;
         });
         child.stderr?.on("data", (chunk) => {
             const buf = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
             entry.stderr.tail.push(buf);
             entry.stderr.totalBytes += buf.length;
+            entry.stderr.acceptedBytes += buf.length;
         });
         child.on("error", () => {
             if (entry.timer)
@@ -1040,8 +1177,8 @@ export class NodeExecutionEnv {
         const shellId = `bg_${++this.bgCounter}_${randomUUID()}`;
         const entry = {
             child,
-            stdout: { tail: new RollingTailBuffer(), totalBytes: 0, cursorBytes: 0 },
-            stderr: { tail: new RollingTailBuffer(), totalBytes: 0, cursorBytes: 0 },
+            stdout: { ...newStreamCursorState(), totalBytes: 0 },
+            stderr: { ...newStreamCursorState(), totalBytes: 0 },
             status: "running",
             ...(spool ? { spool } : {}),
         };
@@ -1051,11 +1188,13 @@ export class NodeExecutionEnv {
             const buf = Buffer.from(chunk, "utf8");
             entry.stdout.tail.push(buf);
             entry.stdout.totalBytes += buf.length;
+            entry.stdout.acceptedBytes += buf.length;
         });
         child.stderr?.on("data", (chunk) => {
             const buf = Buffer.from(chunk, "utf8");
             entry.stderr.tail.push(buf);
             entry.stderr.totalBytes += buf.length;
+            entry.stderr.acceptedBytes += buf.length;
         });
         child.stdout?.on("error", () => { });
         child.stderr?.on("error", () => { });
@@ -1098,21 +1237,18 @@ export class NodeExecutionEnv {
             return err(new BackgroundShellError("not_found", `Unknown background shell: ${shellId}`));
         }
         this.syncSpool(entry);
-        const slice = (s) => {
-            const { text, droppedBytes } = s.tail.result();
-            const droppedBeforeCursor = Math.max(0, droppedBytes - s.cursorBytes);
-            const startByte = Math.max(s.cursorBytes, droppedBytes);
-            const startInTail = startByte - droppedBytes;
-            const inc = startInTail <= 0 ? text : Buffer.from(text, "utf8").subarray(startInTail).toString("utf8");
-            s.cursorBytes = s.totalBytes;
-            return { inc, droppedBeforeCursor };
-        };
-        const out = slice(entry.stdout);
-        const er = slice(entry.stderr);
+        const terminal = entry.status !== "running";
+        const out = sliceStreamIncrement(entry.stdout, terminal);
+        const er = sliceStreamIncrement(entry.stderr, terminal);
         const droppedBeforeCursor = out.droppedBeforeCursor + er.droppedBeforeCursor;
+        let stderrInc = er.inc;
+        if (terminal && (entry.liveRotations ?? 0) > 0 && entry.liveRotationsDisclosed !== true) {
+            entry.liveRotationsDisclosed = true;
+            stderrInc = markLiveSpoolRotations(er.inc, entry.liveRotations ?? 0);
+        }
         return ok({
             stdout: out.inc,
-            stderr: er.inc,
+            stderr: stderrInc,
             status: entry.status,
             ...(entry.exitCode !== undefined ? { exitCode: entry.exitCode } : {}),
             ...(droppedBeforeCursor > 0 ? { truncated: true, bytesDroppedBeforeCursor: droppedBeforeCursor } : {}),
@@ -1165,6 +1301,7 @@ export class NodeExecutionEnv {
                         if (got > 0) {
                             stream.tail.push(buf.subarray(0, got));
                             stream.totalBytes += got;
+                            stream.acceptedBytes += got;
                             spool.fileCursor[lane] += got;
                         }
                     }
@@ -1173,15 +1310,18 @@ export class NodeExecutionEnv {
                     }
                 }
                 if (spool.ephemeral && spool.fileCursor[lane] >= EXEC_SPOOL_ROTATE_BYTES) {
-                    const size2 = statSync(path).size;
-                    if (size2 === spool.fileCursor[lane]) {
-                        truncateSync(path, 0);
-                        spool.fileCursor[lane] = 0;
-                    }
-                    else if (size2 >= EXEC_SPOOL_HARD_CAP_BYTES) {
-                        const skipped = size2 - spool.fileCursor[lane];
-                        stream.tail.recordSkippedBytes(skipped);
-                        stream.totalBytes += skipped;
+                    const d = decideSpoolReclaim({
+                        size: statSync(path).size,
+                        cursor: spool.fileCursor[lane],
+                        writerLive: entry.status === "running" || (entry.child.exitCode === null && entry.child.signalCode === null),
+                    });
+                    if (d.reclaim) {
+                        if (d.skippedBytes > 0) {
+                            stream.tail.recordSkippedBytes(d.skippedBytes);
+                            stream.totalBytes += d.skippedBytes;
+                        }
+                        if (d.live)
+                            entry.liveRotations = (entry.liveRotations ?? 0) + 1;
                         truncateSync(path, 0);
                         spool.fileCursor[lane] = 0;
                     }

package/dist/engine/lsp/frame-decoder.d.ts

@@ -1,2 +1,2 @@
 export declare function encodeFrame(json: string): Buffer;
-export declare function makeFrameDecoder(maxBytes?: number): (chunk: Buffer) => string[];
+export declare function createFrameDecoder(maxBytes?: number): (chunk: Buffer) => string[];

package/dist/engine/lsp/frame-decoder.js

@@ -2,7 +2,7 @@ export function encodeFrame(json) {
     const payload = Buffer.from(json, "utf8");
     return Buffer.concat([Buffer.from(`Content-Length: ${payload.length}\r\n\r\n`, "ascii"), payload]);
 }
-export function makeFrameDecoder(maxBytes = 50 * 1024 * 1024) {
+export function createFrameDecoder(maxBytes = 50 * 1024 * 1024) {
     const HEADER_SLACK = 128;
     let buf = Buffer.alloc(0);
     return function decode(chunk) {

package/dist/engine/lsp/node-lsp-manager.d.ts

@@ -1,7 +1,7 @@
 import { type SessionWarmup } from "../../core/lsp-session.js";
 import { type LspChildProcess } from "./stdio-lsp-transport.js";
-import type { LspServerManager, LspSession, LspReadText } from "../../core/lsp.js";
-import type { ExecutionEnv } from "../../internal/harness.js";
+import { type LspServerManager, type LspSession, type LspReadText } from "../../core/lsp.js";
+import type { ExecutionEnv } from "../../internal/harness-types.js";
 export declare const DEFAULT_LSP_SERVERS: Readonly<Record<string, string>>;
 export type LspSpawn = (command: string, args: string[], cwd: string, signal?: AbortSignal) => Promise<LspChildProcess | undefined>;
 export interface NodeLspManagerOptions {
@@ -40,6 +40,8 @@ export declare class NodeLspManager implements LspServerManager {
     dispose(): Promise<void>;
 }
 export declare function languageFor(filePath: string): string | undefined;
+export { MAX_LSP_FILE_BYTES } from "../../core/lsp.js";
+export declare const defaultLspReadText: LspReadText;
 export declare function lspSpawnOptions(cwd: string): {
     cwd: string;
     stdio: ["pipe", "pipe", "ignore"];

package/dist/engine/lsp/node-lsp-manager.js

@@ -1,12 +1,13 @@
 import { spawn } from "node:child_process";
 import { killProcessTree } from "../execution-env/kill-tree.js";
-import { readFile } from "node:fs/promises";
-import { dirname, extname, resolve as resolvePath } from "node:path";
+import { readFile, stat } from "node:fs/promises";
+import { basename, dirname, extname, resolve as resolvePath } from "node:path";
 import { existsSync } from "node:fs";
 import { pathToUri } from "../../core/lsp-protocol.js";
 import { LspDiagnosticsRegistry } from "../../core/lsp-diagnostics.js";
 import { TransportLspSession } from "../../core/lsp-session.js";
 import { StdioLspTransport } from "./stdio-lsp-transport.js";
+import { MAX_LSP_FILE_BYTES } from "../../core/lsp.js";
 export const DEFAULT_LSP_SERVERS = {
     typescript: "typescript-language-server --stdio",
     javascript: "typescript-language-server --stdio",
@@ -43,7 +44,7 @@ const CLIENT_CAPABILITIES = {
         definition: {}, references: {}, hover: {}, documentSymbol: {}, implementation: {}, callHierarchy: {},
         publishDiagnostics: { versionSupport: true },
     },
-    workspace: { symbol: {} },
+    workspace: { symbol: {}, workspaceFolders: false },
 };
 export class NodeLspManager {
     servers;
@@ -62,7 +63,7 @@ export class NodeLspManager {
     constructor(opts = {}) {
         this.servers = { ...DEFAULT_LSP_SERVERS, ...opts.servers };
         this.spawnFn = opts.spawn ?? defaultLspSpawn;
-        this.readTextFn = opts.readText ?? ((fp) => readFile(fp, "utf8"));
+        this.readTextFn = opts.readText ?? defaultLspReadText;
         this.resolveRootFn = opts.resolveRoot ?? defaultResolveRoot;
         this.log = opts.log ?? (() => { });
         this.warmup = opts.warmup;
@@ -175,7 +176,14 @@ export class NodeLspManager {
         }
         const transport = new StdioLspTransport(child);
         try {
-            await transport.request("initialize", { processId: null, rootUri: pathToUri(root), capabilities: CLIENT_CAPABILITIES }, signal);
+            const rootUri = pathToUri(root);
+            await transport.request("initialize", {
+                processId: null,
+                rootPath: root,
+                rootUri,
+                workspaceFolders: [{ uri: rootUri, name: basename(root) || root }],
+                capabilities: CLIENT_CAPABILITIES,
+            }, signal);
             transport.notify("initialized", {});
         }
         catch (e) {
@@ -218,6 +226,15 @@ function defaultResolveRoot(filePath, env) {
     }
     return dirname(resolvePath(filePath));
 }
+export { MAX_LSP_FILE_BYTES } from "../../core/lsp.js";
+export const defaultLspReadText = async (fp, signal) => {
+    const st = await stat(fp);
+    if (!st.isFile())
+        throw new Error(`not a regular file: ${fp}`);
+    if (st.size > MAX_LSP_FILE_BYTES)
+        throw new Error(`file too large for LSP analysis (${st.size} bytes exceeds ${MAX_LSP_FILE_BYTES})`);
+    return readFile(fp, { encoding: "utf8", signal });
+};
 export function lspSpawnOptions(cwd) {
     return process.platform === "win32"
         ? { cwd, stdio: ["pipe", "pipe", "ignore"], shell: true }

package/dist/engine/lsp/stdio-lsp-transport.d.ts

@@ -1,4 +1,4 @@
-import type { LspTransport } from "../../core/lsp.js";
+import { type LspTransport } from "../../core/lsp.js";
 export interface LspChildProcess {
     stdin: {
         write(data: Buffer): void;

package/dist/engine/lsp/stdio-lsp-transport.js

@@ -1,12 +1,13 @@
-import { encodeFrame, makeFrameDecoder } from "./frame-decoder.js";
+import { encodeFrame, createFrameDecoder } from "./frame-decoder.js";
 import { killProcessTree } from "../execution-env/kill-tree.js";
+import { brandLspFailure } from "../../core/lsp.js";
 export class StdioLspTransport {
     child;
     requestTimeoutMs;
     nextId = 0;
     pending = new Map();
     isClosed = false;
-    decode = makeFrameDecoder();
+    decode = createFrameDecoder();
     notificationHandlers = new Set();
     constructor(child, requestTimeoutMs = 30_000) {
         this.child = child;
@@ -44,8 +45,10 @@ export class StdioLspTransport {
             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"));
+                if (msg.error) {
+                    const message = msg.error.message ?? "LSP error";
+                    p.reject(brandLspFailure(new Error(message), jsonRpcReason(msg.error.code), message));
+                }
                 else
                     p.resolve(msg.result);
             }
@@ -68,6 +71,7 @@ export class StdioLspTransport {
     }
     failAll(err) {
         this.isClosed = true;
+        brandLspFailure(err, "server_terminated");
         for (const p of this.pending.values())
             p.reject(err);
         this.pending.clear();
@@ -77,13 +81,13 @@ export class StdioLspTransport {
     }
     request(method, params, signal) {
         if (this.isClosed)
-            return Promise.reject(new Error("LSP transport closed"));
+            return Promise.reject(brandLspFailure(new Error("LSP transport closed"), "server_terminated"));
         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`));
+                    reject(brandLspFailure(new Error(`LSP ${method} timed out after ${this.requestTimeoutMs}ms`), "timeout"));
                 }
             }, this.requestTimeoutMs);
             timer.unref?.();
@@ -95,7 +99,7 @@ export class StdioLspTransport {
                 if (this.pending.delete(id)) {
                     cleanup();
                     this.notify("$/cancelRequest", { id });
-                    reject(new Error(`LSP ${method} aborted`));
+                    reject(brandLspFailure(new Error(`LSP ${method} aborted`), "cancelled"));
                 }
             };
             this.pending.set(id, {
@@ -119,7 +123,7 @@ export class StdioLspTransport {
             catch (e) {
                 if (this.pending.delete(id)) {
                     cleanup();
-                    reject(e instanceof Error ? e : new Error(String(e)));
+                    reject(brandLspFailure(e instanceof Error ? e : new Error(String(e)), "server_terminated"));
                 }
             }
         });
@@ -145,6 +149,13 @@ export class StdioLspTransport {
         }
     }
 }
+function jsonRpcReason(code) {
+    if (code === -32601)
+        return "unsupported_operation";
+    if (code === -32800 || code === -32802)
+        return "cancelled";
+    return "server_error";
+}
 function toError(e) {
     if (e instanceof Error)
         return e;