@prometheus-ai/agent 0.5.3 → 0.5.8

package/src/dap/client.ts

@@ -1,4 +1,5 @@
-import { logger, ptree } from "@prometheus-ai/utils";
+import * as fs from "node:fs/promises";
+import { isEnoent, logger, ptree } from "@prometheus-ai/utils";
 import { NON_INTERACTIVE_ENV } from "../exec/non-interactive-env";
 import { ToolAbortError } from "../tools/tool-errors";
 import type {
@@ -28,32 +29,67 @@ type DapReverseRequestHandler = (args: unknown) => unknown | Promise<unknown>;
 
 const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
 
-function findHeaderEnd(buffer: Uint8Array): number {
-	for (let index = 0; index < buffer.length - 3; index += 1) {
-		if (buffer[index] === 13 && buffer[index + 1] === 10 && buffer[index + 2] === 13 && buffer[index + 3] === 10) {
-			return index;
+// Reused for all full decodes; each decode() resets state, so a single
+// instance is safe and avoids per-message TextDecoder allocation.
+const MESSAGE_DECODER = new TextDecoder("utf-8");
+
+/**
+ * Locate the `\r\n\r\n` header terminator across the pending chunk list.
+ * Returns the absolute byte index of the first `\r`, or -1 when not present.
+ * Equivalent to scanning the contiguous concatenation of the chunks.
+ */
+function findHeaderEndInChunks(chunks: Buffer[]): number {
+	let global = 0;
+	let b0 = -1;
+	let b1 = -1;
+	let b2 = -1;
+	for (const chunk of chunks) {
+		for (let i = 0; i < chunk.length; i++) {
+			const b3 = chunk[i];
+			if (b0 === 13 && b1 === 10 && b2 === 13 && b3 === 10) {
+				return global - 3;
+			}
+			b0 = b1;
+			b1 = b2;
+			b2 = b3;
+			global++;
 		}
 	}
 	return -1;
 }
 
-function parseMessage(
-	buffer: Buffer,
-): { message: DapResponseMessage | DapEventMessage | DapRequestMessage; remaining: Buffer } | null {
-	const headerEndIndex = findHeaderEnd(buffer);
-	if (headerEndIndex === -1) return null;
-	const headerText = new TextDecoder().decode(buffer.slice(0, headerEndIndex));
-	const contentLengthMatch = headerText.match(/Content-Length: (\d+)/i);
-	if (!contentLengthMatch) return null;
-	const contentLength = Number.parseInt(contentLengthMatch[1], 10);
-	const messageStart = headerEndIndex + 4;
-	const messageEnd = messageStart + contentLength;
-	if (buffer.length < messageEnd) return null;
-	const messageText = new TextDecoder().decode(buffer.subarray(messageStart, messageEnd));
-	return {
-		message: JSON.parse(messageText) as DapResponseMessage | DapEventMessage | DapRequestMessage,
-		remaining: buffer.subarray(messageEnd),
-	};
+/** Copy the byte range [from, to) out of the pending chunk list into one Buffer. */
+function copyChunkRange(chunks: Buffer[], from: number, to: number): Buffer {
+	const out = Buffer.allocUnsafe(to - from);
+	let global = 0;
+	let written = 0;
+	for (const chunk of chunks) {
+		const chunkEnd = global + chunk.length;
+		if (chunkEnd > from && global < to) {
+			const start = Math.max(from, global) - global;
+			const end = Math.min(to, chunkEnd) - global;
+			chunk.copy(out, written, start, end);
+			written += end - start;
+		}
+		global = chunkEnd;
+		if (global >= to) break;
+	}
+	return out;
+}
+
+/** Drop the first `count` bytes from the pending chunk list in place. */
+function dropChunkFront(chunks: Buffer[], count: number): void {
+	let removed = 0;
+	while (chunks.length > 0) {
+		const head = chunks[0];
+		if (removed + head.length <= count) {
+			removed += head.length;
+			chunks.shift();
+		} else {
+			chunks[0] = head.subarray(count - removed);
+			break;
+		}
+	}
 }
 
 async function writeMessage(sink: DapWriteSink, message: DapRequestMessage | DapResponseMessage): Promise<void> {
@@ -80,7 +116,7 @@ export class DapClient {
 	readonly #socket?: { end(): void };
 	#requestSeq = 0;
 	#pendingRequests = new Map<number, DapPendingRequest>();
-	#messageBuffer = Buffer.alloc(0);
+	#messageBuffer: Buffer = Buffer.alloc(0);
 	#isReading = false;
 	#disposed = false;
 	#lastActivity = Date.now();
@@ -165,19 +201,7 @@ export class DapClient {
 			detached: true,
 		});
 
-		// Wait for the socket file to appear (dlv needs to start listening)
-		await waitForCondition(
-			() => {
-				try {
-					Bun.file(socketPath).size;
-					return true;
-				} catch {
-					return false;
-				}
-			},
-			10_000,
-			proc,
-		);
+		await waitForCondition(() => isUnixSocketReady(socketPath), 10_000, proc);
 
 		const { readable, writeSink, socket } = await connectSocket({ unix: socketPath });
 		const client = new DapClient(adapter, cwd, proc, { readable, writeSink, socket });
@@ -427,32 +451,84 @@ export class DapClient {
 		if (this.#isReading) return;
 		this.#isReading = true;
 		const reader = this.#readable.getReader();
+
+		// Incoming bytes are buffered as a list of chunks and only joined when a
+		// full message is framed (mirrors the LSP reader) — concatenating the
+		// accumulator on every read is O(n^2) for messages spanning many reads.
+		const pendingChunks: Buffer[] = [];
+		let pendingLen = 0;
+		if (this.#messageBuffer.length > 0) {
+			pendingChunks.push(this.#messageBuffer);
+			pendingLen = this.#messageBuffer.length;
+		}
+
 		try {
 			while (true) {
 				const { done, value } = await reader.read();
 				if (done) break;
-				const currentBuffer = Buffer.concat([this.#messageBuffer, value]);
-				this.#messageBuffer = currentBuffer;
-				let workingBuffer = currentBuffer;
-				let parsed = parseMessage(workingBuffer);
-				while (parsed) {
-					const { message, remaining } = parsed;
-					workingBuffer = Buffer.from(remaining);
+
+				pendingChunks.push(Buffer.from(value));
+				pendingLen += value.length;
+
+				// Drain every complete message currently buffered.
+				while (true) {
+					const headerEnd = findHeaderEndInChunks(pendingChunks);
+					if (headerEnd === -1) break;
+
+					const headerText = MESSAGE_DECODER.decode(copyChunkRange(pendingChunks, 0, headerEnd));
+					const contentLengthMatch = headerText.match(/Content-Length: (\d+)/i);
+					if (!contentLengthMatch) {
+						// Non-protocol bytes (e.g. an adapter printing to stdout).
+						// Drop past the bogus terminator and resync instead of
+						// stalling on the same junk header forever.
+						logger.warn("DAP framing resync: header block without Content-Length", {
+							adapter: this.adapter.name,
+							header: headerText.slice(0, 200),
+						});
+						dropChunkFront(pendingChunks, headerEnd + 4);
+						pendingLen -= headerEnd + 4;
+						continue;
+					}
+
+					const contentLength = Number.parseInt(contentLengthMatch[1], 10);
+					const messageStart = headerEnd + 4; // Skip \r\n\r\n
+					const messageEnd = messageStart + contentLength;
+					if (pendingLen < messageEnd) break;
+
+					const messageText = MESSAGE_DECODER.decode(copyChunkRange(pendingChunks, messageStart, messageEnd));
+					dropChunkFront(pendingChunks, messageEnd);
+					pendingLen -= messageEnd;
 					this.#lastActivity = Date.now();
-					if (message.type === "response") {
-						this.#handleResponse(message);
-					} else if (message.type === "event") {
-						await this.#dispatchEvent(message);
-					} else {
-						await this.#handleAdapterRequest(message);
+
+					// A malformed message must not kill the reader — later
+					// messages are still well-framed.
+					try {
+						const message = JSON.parse(messageText) as DapResponseMessage | DapEventMessage | DapRequestMessage;
+						if (message.type === "response") {
+							this.#handleResponse(message);
+						} else if (message.type === "event") {
+							await this.#dispatchEvent(message);
+						} else {
+							await this.#handleAdapterRequest(message);
+						}
+					} catch (error) {
+						logger.warn("DAP message handling failed", {
+							adapter: this.adapter.name,
+							error: toErrorMessage(error),
+						});
 					}
-					parsed = parseMessage(workingBuffer);
 				}
-				this.#messageBuffer = workingBuffer;
 			}
 		} catch (error) {
 			this.#rejectPendingRequests(new Error(`DAP connection closed: ${toErrorMessage(error)}`));
 		} finally {
+			// Persist any unparsed remainder so a restarted reader resumes mid-message.
+			this.#messageBuffer =
+				pendingChunks.length === 0
+					? Buffer.alloc(0)
+					: pendingChunks.length === 1
+						? pendingChunks[0]
+						: Buffer.concat(pendingChunks, pendingLen);
 			reader.releaseLock();
 			this.#isReading = false;
 		}
@@ -553,15 +629,24 @@ export class DapClient {
 	}
 }
 
+async function isUnixSocketReady(socketPath: string): Promise<boolean> {
+	try {
+		return (await fs.stat(socketPath)).isSocket();
+	} catch (error) {
+		if (isEnoent(error)) return false;
+		throw error;
+	}
+}
+
 /** Poll a condition until it returns true, or timeout/process exit. */
 async function waitForCondition(
-	check: () => boolean,
+	check: () => boolean | Promise<boolean>,
 	timeoutMs: number,
 	proc: { exitCode: number | null },
 ): Promise<void> {
 	const deadline = Date.now() + timeoutMs;
 	while (Date.now() < deadline) {
-		if (check()) return;
+		if (await check()) return;
 		if (proc.exitCode !== null) {
 			throw new Error("Adapter process exited before socket was ready");
 		}

package/src/dap/config.ts

@@ -27,6 +27,7 @@ function normalizeAdapterConfig(config: unknown): DapAdapterConfig | null {
 		rootMarkers: normalizeStringArray(config.rootMarkers),
 		launchDefaults: normalizeObject(config.launchDefaults),
 		attachDefaults: normalizeObject(config.attachDefaults),
+		acceptsDirectoryProgram: config.acceptsDirectoryProgram === true,
 		...(connectMode ? { connectMode } : {}),
 	};
 }
@@ -64,6 +65,7 @@ export function resolveAdapter(adapterName: string, cwd: string): DapResolvedAda
 		launchDefaults: config.launchDefaults ?? {},
 		attachDefaults: config.attachDefaults ?? {},
 		connectMode: config.connectMode ?? "stdio",
+		acceptsDirectoryProgram: config.acceptsDirectoryProgram === true,
 	};
 }
 
@@ -124,12 +126,19 @@ function sortAdaptersForLaunch(program: string, cwd: string, adapters: DapResolv
 	return rootAware.map(entry => entry.adapter);
 }
 
-export function selectLaunchAdapter(program: string, cwd: string, adapterName?: string): DapResolvedAdapter | null {
+export function selectLaunchAdapter(
+	program: string,
+	cwd: string,
+	adapterName?: string,
+	programKind: LaunchProgramKind = "file",
+): DapResolvedAdapter | null {
 	if (adapterName) {
 		return resolveAdapter(adapterName, cwd);
 	}
 	const matches = getMatchingAdapters(program, cwd);
-	const sorted = sortAdaptersForLaunch(program, cwd, matches);
+	const candidates =
+		programKind === "directory" ? matches.filter(adapter => adapter.acceptsDirectoryProgram) : matches;
+	const sorted = sortAdaptersForLaunch(program, cwd, candidates.length > 0 ? candidates : matches);
 	return sorted[0] ?? null;
 }
 
@@ -148,3 +157,33 @@ export function selectAttachAdapter(cwd: string, adapterName?: string, port?: nu
 	}
 	return available[0] ?? null;
 }
+
+/** How the launch `program` resolves on disk. `"missing"` is reserved for
+ *  programs the adapter creates on demand (rare); we treat them like files. */
+export type LaunchProgramKind = "file" | "directory" | "missing";
+
+/** Compute adapter-specific launch arguments that depend on the resolved
+ *  program. Returned values are spread over `adapter.launchDefaults` so they
+ *  take precedence over the static defaults but can still be overridden by
+ *  the fields `DapSessionManager.launch` sets explicitly (program, cwd, args).
+ *
+ *  Currently scoped to dlv, where `mode` selects how the program path is
+ *  interpreted: directories and `.go` source files debug as a Go package
+ *  (`mode=debug`), anything else is treated as a compiled binary (`mode=exec`).
+ */
+export function resolveLaunchOverrides(
+	adapter: DapResolvedAdapter,
+	program: string,
+	programKind: LaunchProgramKind,
+): Record<string, unknown> {
+	if (adapter.name === "dlv") {
+		const extension = path.extname(program).toLowerCase();
+		if (programKind === "directory" || extension === ".go") {
+			return { mode: "debug" };
+		}
+		if (programKind === "file") {
+			return { mode: "exec" };
+		}
+	}
+	return {};
+}

package/src/dap/defaults.json

@@ -65,6 +65,7 @@
 		"languages": ["go"],
 		"fileTypes": [".go"],
 		"rootMarkers": ["go.mod", "go.sum"],
+		"acceptsDirectoryProgram": true,
 		"launchDefaults": {
 			"request": "launch",
 			"mode": "debug",