@gajae-code/coding-agent 0.12.6 → 0.12.8

package/src/internal-urls/agent-protocol.ts

@@ -11,16 +11,11 @@
  * - agent://<id>?q=<query> - JSON extraction via query form
  */
 import { createHash } from "node:crypto";
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { isEnoent } from "@gajae-code/utils";
 import { applyQuery, pathToQuery } from "./json-query";
-import {
-	type AuthorizedArtifactsRoot,
-	authorizedArtifactsDirsFromContext,
-	closeAuthorizedArtifactsRoot,
-	openAuthorizedArtifactsRoot,
-	readAuthorizedArtifactFile,
-} from "./registry-helpers";
+import { authorizedArtifactsDirsFromContext } from "./registry-helpers";
 import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext } from "./types";
 
 interface AgentOutputMetadata {
@@ -41,24 +36,6 @@ interface ManagedOutputSelector {
 	metadataSha256: string;
 }
 
-const MAX_AGENT_SELECTOR_BYTES = 64 * 1024;
-const MAX_AGENT_METADATA_BYTES = 1024 * 1024;
-const MAX_AGENT_OUTPUT_BYTES = 16 * 1024 * 1024;
-
-function readRetainedAgentFile(
-	outputId: string,
-	root: AuthorizedArtifactsRoot,
-	filename: string,
-	maxBytes: number,
-): Buffer | null {
-	const captured = readAuthorizedArtifactFile(root, filename, maxBytes);
-	if (!captured) return null;
-	if (captured.size !== captured.bytes.byteLength) {
-		throw new Error(`agent://${outputId} retained file exceeds read capacity`);
-	}
-	return captured.bytes;
-}
-
 function isSafeGenerationFilename(filename: unknown): filename is string {
 	return typeof filename === "string" && /^[a-zA-Z0-9_.-]+$/.test(filename);
 }
@@ -79,14 +56,17 @@ function isManagedOutputSelector(value: unknown, outputId: string): value is Man
 	);
 }
 
-function readManagedOutputSelector(
+async function readManagedOutputSelector(
 	outputId: string,
-	root: AuthorizedArtifactsRoot,
-	selectorFilename: string,
-): ManagedOutputSelector | null {
-	const bytes = readRetainedAgentFile(outputId, root, selectorFilename, MAX_AGENT_SELECTOR_BYTES);
-	if (!bytes) return null;
-	const raw = bytes.toString("utf8");
+	selectorPath: string,
+): Promise<ManagedOutputSelector | null> {
+	let raw: string;
+	try {
+		raw = await Bun.file(selectorPath).text();
+	} catch (error) {
+		if (isEnoent(error)) return null;
+		throw error;
+	}
 	let parsed: unknown;
 	try {
 		parsed = JSON.parse(raw);
@@ -96,18 +76,6 @@ function readManagedOutputSelector(
 	if (!isManagedOutputSelector(parsed, outputId)) throw new Error(`agent://${outputId} malformed output selector`);
 	return parsed;
 }
-function sameManagedOutputSelector(left: ManagedOutputSelector, right: ManagedOutputSelector): boolean {
-	return (
-		left.outputFilename === right.outputFilename &&
-		left.metadataFilename === right.metadataFilename &&
-		left.outputSizeBytes === right.outputSizeBytes &&
-		left.outputSha256 === right.outputSha256 &&
-		left.metadataSizeBytes === right.metadataSizeBytes &&
-		left.metadataSha256 === right.metadataSha256
-	);
-}
-
-const MANAGED_SELECTOR_READ_ATTEMPTS = 8;
 
 function isAgentOutputMetadata(value: unknown, outputId: string): value is AgentOutputMetadata {
 	if (!value || typeof value !== "object") return false;
@@ -124,11 +92,18 @@ function isAgentOutputMetadata(value: unknown, outputId: string): value is Agent
 
 async function verifyAgentOutputMetadata(
 	outputId: string,
-	metadataBytes: Buffer,
+	foundPath: string,
+	metadataPath: string,
 	bytes: Buffer,
 	selector?: ManagedOutputSelector,
 ): Promise<void> {
-	const metaRaw = metadataBytes.toString("utf8");
+	let metaRaw: string;
+	try {
+		metaRaw = await Bun.file(metadataPath).text();
+	} catch (err) {
+		if (isEnoent(err)) throw new Error(`agent://${outputId} missing metadata`);
+		throw err;
+	}
 	let parsed: unknown;
 	try {
 		parsed = JSON.parse(metaRaw);
@@ -138,7 +113,9 @@ async function verifyAgentOutputMetadata(
 	if (!isAgentOutputMetadata(parsed, outputId)) {
 		throw new Error(`agent://${outputId} malformed metadata`);
 	}
-	if (bytes.byteLength !== parsed.sizeBytes) {
+	const metadataBytes = Buffer.from(metaRaw, "utf8");
+	const stat = await fs.stat(foundPath);
+	if (stat.size !== parsed.sizeBytes || bytes.byteLength !== parsed.sizeBytes) {
 		throw new Error(`agent://${outputId} size mismatch`);
 	}
 	const sha256 = createHash("sha256").update(bytes).digest("hex");
@@ -195,64 +172,27 @@ export class AgentProtocolHandler implements ProtocolHandler {
 		let foundPath: string | undefined;
 		let foundMetadataPath: string | undefined;
 		let foundSelector: ManagedOutputSelector | undefined;
-		let foundBytes: Buffer | undefined;
-		let foundMetadataBytes: Buffer | undefined;
 		let anyDirExists = false;
 
 		for (const dir of dirs) {
-			let root: AuthorizedArtifactsRoot;
 			try {
-				root = openAuthorizedArtifactsRoot(dir);
+				await fs.stat(dir);
 				anyDirExists = true;
 			} catch (err) {
 				if (isEnoent(err)) continue;
 				throw err;
 			}
+			const selector = await readManagedOutputSelector(outputId, path.join(dir, `${outputId}.md.selector.json`));
+			const candidate = selector ? path.join(dir, selector.outputFilename) : path.join(dir, `${outputId}.md`);
+			const metadataPath = selector ? path.join(dir, selector.metadataFilename) : `${candidate}.meta.json`;
 			try {
-				const selectorFilename = `${outputId}.md.selector.json`;
-				let selector = readManagedOutputSelector(outputId, root, selectorFilename);
-				for (let attempt = 0; attempt < MANAGED_SELECTOR_READ_ATTEMPTS; attempt++) {
-					const candidateFilename = selector ? selector.outputFilename : `${outputId}.md`;
-					const metadataFilename = selector ? selector.metadataFilename : `${candidateFilename}.meta.json`;
-					const rawBuffer = readRetainedAgentFile(outputId, root, candidateFilename, MAX_AGENT_OUTPUT_BYTES);
-					const metadataBuffer = readRetainedAgentFile(outputId, root, metadataFilename, MAX_AGENT_METADATA_BYTES);
-					if (rawBuffer && metadataBuffer) {
-						if (selector) {
-							const refreshed = readManagedOutputSelector(outputId, root, selectorFilename);
-							if (!refreshed || !sameManagedOutputSelector(selector, refreshed)) {
-								if (attempt + 1 >= MANAGED_SELECTOR_READ_ATTEMPTS) {
-									throw new Error(`agent://${outputId} generation changed during read`);
-								}
-								if (!refreshed) throw new Error(`agent://${outputId} generation changed during read`);
-								selector = refreshed;
-								continue;
-							}
-						}
-						if (foundPath) throw new Error(`agent://${outputId} ambiguous id in authorized artifacts`);
-						foundPath = path.join(dir, candidateFilename);
-						foundMetadataPath = path.join(dir, metadataFilename);
-						foundSelector = selector ?? undefined;
-						foundBytes = rawBuffer;
-						foundMetadataBytes = metadataBuffer;
-						break;
-					}
-					if (!selector) {
-						if (!rawBuffer) break;
-						throw new Error(`agent://${outputId} missing metadata`);
-					}
-					if (attempt + 1 >= MANAGED_SELECTOR_READ_ATTEMPTS) {
-						throw new Error(`agent://${outputId} generation changed during read`);
-					}
-					const refreshed = readManagedOutputSelector(outputId, root, selectorFilename);
-					if (!refreshed) throw new Error(`agent://${outputId} generation changed during read`);
-					if (sameManagedOutputSelector(selector, refreshed)) {
-						if (!rawBuffer) throw new Error(`agent://${outputId} selected generation unavailable`);
-						throw new Error(`agent://${outputId} missing metadata`);
-					}
-					selector = refreshed;
-				}
-			} finally {
-				closeAuthorizedArtifactsRoot(root);
+				await fs.stat(candidate);
+				if (foundPath) throw new Error(`agent://${outputId} ambiguous id in authorized artifacts`);
+				foundPath = candidate;
+				foundMetadataPath = metadataPath;
+				foundSelector = selector ?? undefined;
+			} catch (err) {
+				if (!isEnoent(err)) throw err;
 			}
 		}
 
@@ -260,12 +200,12 @@ export class AgentProtocolHandler implements ProtocolHandler {
 			throw new Error("No artifacts directory found");
 		}
 
-		if (!foundPath || !foundMetadataPath || !foundBytes || !foundMetadataBytes) {
+		if (!foundPath) {
 			throw new Error(`agent://${outputId} not found`);
 		}
 
-		const rawBytes = foundBytes;
-		await verifyAgentOutputMetadata(outputId, foundMetadataBytes, rawBytes, foundSelector);
+		const rawBytes = Buffer.from(await Bun.file(foundPath).arrayBuffer());
+		await verifyAgentOutputMetadata(outputId, foundPath, foundMetadataPath!, rawBytes, foundSelector);
 		const rawContent = rawBytes.toString("utf8");
 		const notes: string[] = [];
 		let content = rawContent;

package/src/internal-urls/artifact-protocol.ts

@@ -12,14 +12,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { isEnoent } from "@gajae-code/utils";
-import { isValidArtifactId } from "../utils/artifact-id";
-import {
-	type AuthorizedArtifactsRoot,
-	authorizedArtifactsDirsFromContext,
-	closeAuthorizedArtifactsRoot,
-	openAuthorizedArtifactsRoot,
-	readAuthorizedArtifactFile,
-} from "./registry-helpers";
+import { authorizedArtifactsDirsFromContext } from "./registry-helpers";
 import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext } from "./types";
 
 export class ArtifactProtocolHandler implements ProtocolHandler {
@@ -31,7 +24,7 @@ export class ArtifactProtocolHandler implements ProtocolHandler {
 		if (!id) {
 			throw new Error("artifact:// URL requires a numeric ID: artifact://0");
 		}
-		if (!isValidArtifactId(id)) {
+		if (!/^\d+$/.test(id)) {
 			throw new Error(`artifact:// ID must be numeric, got: ${id}`);
 		}
 
@@ -42,33 +35,23 @@ export class ArtifactProtocolHandler implements ProtocolHandler {
 		}
 
 		let foundPath: string | undefined;
-		let foundBytes: Buffer | undefined;
-		let foundSize = 0;
 		let anyDirExists = false;
-		const MAX_ARTIFACT_READ_BYTES = 16 * 1024 * 1024;
 
 		for (const dir of dirs) {
-			let root: AuthorizedArtifactsRoot;
+			let files: string[];
 			try {
-				root = openAuthorizedArtifactsRoot(dir);
+				files = await fs.readdir(dir);
 				anyDirExists = true;
 			} catch (err) {
 				if (isEnoent(err)) continue;
 				throw err;
 			}
-			try {
-				const files = await fs.readdir(dir);
-				for (const f of files) {
-					if (f.endsWith(".meta.json") || !f.startsWith(`${id}.`)) continue;
-					const captured = readAuthorizedArtifactFile(root, f, MAX_ARTIFACT_READ_BYTES);
-					if (!captured) continue;
+			for (const f of files) {
+				if (f.endsWith(".meta.json")) continue;
+				if (f.startsWith(`${id}.`)) {
 					if (foundPath) throw new Error(`artifact://${id} ambiguous id in authorized artifacts`);
 					foundPath = path.join(dir, f);
-					foundBytes = captured.bytes;
-					foundSize = captured.size;
 				}
-			} finally {
-				closeAuthorizedArtifactsRoot(root);
 			}
 		}
 
@@ -76,14 +59,20 @@ export class ArtifactProtocolHandler implements ProtocolHandler {
 			throw new Error("No artifacts directory found");
 		}
 
-		if (!foundPath || !foundBytes) {
+		if (!foundPath) {
 			throw new Error(`artifact://${id} not found`);
 		}
 
+		// F20: cap the materialized artifact so reading a huge spilled artifact cannot
+		// buffer GBs into memory (the range selector is applied downstream, so without a
+		// cap a `artifact://id:range` over a multi-GB artifact still reads it whole).
+		const MAX_ARTIFACT_READ_BYTES = 16 * 1024 * 1024;
+		const file = Bun.file(foundPath);
+		const fullSize = file.size;
 		const content =
-			foundSize > foundBytes.byteLength
-				? `${foundBytes.toString("utf8")}\n\n[Artifact truncated: first ${foundBytes.byteLength} of ${foundSize} bytes shown; use a narrower range or a specialized tool for the full content.]`
-				: foundBytes.toString("utf8");
+			fullSize > MAX_ARTIFACT_READ_BYTES
+				? `${await file.slice(0, MAX_ARTIFACT_READ_BYTES).text()}\n\n[Artifact truncated: first ${MAX_ARTIFACT_READ_BYTES} of ${fullSize} bytes shown; use a narrower range or a specialized tool for the full content.]`
+				: await file.text();
 		return {
 			url: url.href,
 			content,