@gajae-code/coding-agent 0.11.3 → 0.11.5

package/src/session/artifacts.ts

@@ -4,10 +4,61 @@
  * Artifacts are stored in a directory alongside the session file,
  * accessible via artifact:// URLs.
  */
+
+import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs/promises";
-import * as path from "node:path";
 
+import * as path from "node:path";
+import {
+	ensureManagedDirectory,
+	type ManagedSessionDescendantStore,
+	publishManagedFileNoReplace,
+} from "./internal/managed-session-storage";
 import { DEFAULT_ARTIFACT_MAX_BYTES, truncateHeadBytes } from "./streaming-output";
+
+export interface ManagedOutputGeneration {
+	outputFilename: string;
+	metadataFilename: string;
+	outputSizeBytes: number;
+	outputSha256: string;
+	metadataSizeBytes: number;
+	metadataSha256: string;
+}
+
+function sha256(bytes: Uint8Array): string {
+	return createHash("sha256").update(bytes).digest("hex");
+}
+
+function isSafeFilename(filename: string): boolean {
+	return /^[a-zA-Z0-9_.-]+$/.test(filename);
+}
+
+function parseManagedOutputGeneration(value: Uint8Array, outputFilenamePrefix: string): ManagedOutputGeneration | null {
+	try {
+		const parsed = JSON.parse(Buffer.from(value).toString("utf8")) as Partial<ManagedOutputGeneration>;
+		if (
+			typeof parsed.outputFilename !== "string" ||
+			typeof parsed.metadataFilename !== "string" ||
+			typeof parsed.outputSizeBytes !== "number" ||
+			typeof parsed.outputSha256 !== "string" ||
+			typeof parsed.metadataSizeBytes !== "number" ||
+			typeof parsed.metadataSha256 !== "string" ||
+			!isSafeFilename(parsed.outputFilename) ||
+			!isSafeFilename(parsed.metadataFilename) ||
+			!parsed.outputFilename.startsWith(`${outputFilenamePrefix}.`) ||
+			!parsed.outputFilename.endsWith(".output") ||
+			parsed.metadataFilename !== `${parsed.outputFilename}.meta.json`
+		)
+			return null;
+		return parsed as ManagedOutputGeneration;
+	} catch {
+		return null;
+	}
+}
+
+function sameGeneration(left: ManagedOutputGeneration, right: ManagedOutputGeneration): boolean {
+	return left.outputFilename === right.outputFilename && left.metadataFilename === right.metadataFilename;
+}
 export interface ArtifactSaveOptions {
 	maxBytes?: number;
 }
@@ -25,14 +76,16 @@ export interface ArtifactSaveOptions {
 export class ArtifactManager {
 	#nextId = 0;
 	readonly #dir: string;
+	readonly #store: ManagedSessionDescendantStore | undefined;
 	#dirCreated = false;
 	#initialized = false;
 
 	/**
 	 * @param dir Directory that will hold artifact files. Created lazily on first save.
 	 */
-	constructor(dir: string) {
-		this.#dir = dir;
+	constructor(target: string | ManagedSessionDescendantStore) {
+		this.#store = typeof target === "string" ? undefined : target;
+		this.#dir = typeof target === "string" ? target : target.dir;
 	}
 
 	/**
@@ -43,9 +96,26 @@ export class ArtifactManager {
 		return this.#dir;
 	}
 
+	getManagedRootAuthority() {
+		return this.#store?.rootAuthority;
+	}
+
+	getManagedSubtreeRootAuthority() {
+		return this.#store?.subtreeRootAuthority;
+	}
+
+	getManagedStore(): ManagedSessionDescendantStore | undefined {
+		return this.#store;
+	}
+
+	assertManagedBinding(): void {
+		this.#store?.assertBound();
+	}
+
 	async #ensureDir(): Promise<void> {
 		if (!this.#dirCreated) {
-			await fs.mkdir(this.#dir, { recursive: true });
+			if (this.#store) this.#store.ensureDirectory();
+			else ensureManagedDirectory(this.#dir);
 			this.#dirCreated = true;
 		}
 		if (!this.#initialized) {
@@ -54,6 +124,102 @@ export class ArtifactManager {
 		}
 	}
 
+	#filename(id: string, toolType: string): string {
+		if (!/^[a-zA-Z0-9_-]+$/.test(toolType)) throw new Error("Unsafe artifact tool type");
+		return `${id}.${toolType}.log`;
+	}
+
+	async #publish(content: string, filename: string): Promise<void> {
+		if (this.#store) await this.#store.publishNoReplace(filename, Buffer.from(content, "utf8"));
+		else await publishManagedFileNoReplace(path.join(this.#dir, filename), Buffer.from(content, "utf8"));
+	}
+
+	async replaceNamed(filename: string, content: string): Promise<void> {
+		if (!/^[a-zA-Z0-9_.-]+$/.test(filename)) throw new Error("Unsafe named artifact");
+		await this.#ensureDir();
+		if (this.#store) await this.#store.replace(filename, Buffer.from(content, "utf8"));
+		else await Bun.write(path.join(this.#dir, filename), content);
+	}
+
+	async replaceNamedBytes(filename: string, bytes: Uint8Array): Promise<void> {
+		if (!/^[a-zA-Z0-9_.-]+$/.test(filename)) throw new Error("Unsafe named artifact");
+		await this.#ensureDir();
+		if (this.#store) await this.#store.replace(filename, bytes);
+		else await Bun.write(path.join(this.#dir, filename), bytes);
+	}
+
+	async publishManagedOutputGeneration(
+		selectorFilename: string,
+		outputFilenamePrefix: string,
+		outputBytes: Uint8Array,
+		metadataBytes: Uint8Array,
+	): Promise<void> {
+		if (!isSafeFilename(selectorFilename) || !isSafeFilename(outputFilenamePrefix)) {
+			throw new Error("Unsafe managed output generation");
+		}
+		await this.#ensureDir();
+		if (!this.#store) throw new Error("Managed output generation requires retained authority");
+
+		const priorSelector = this.#store.readExpected(selectorFilename);
+		const priorGeneration = priorSelector
+			? parseManagedOutputGeneration(priorSelector.bytes, outputFilenamePrefix)
+			: null;
+		const generationId = randomUUID();
+		const outputFilename = `${outputFilenamePrefix}.${generationId}.output`;
+		const metadataFilename = `${outputFilename}.meta.json`;
+		const generation: ManagedOutputGeneration = {
+			outputFilename,
+			metadataFilename,
+			outputSizeBytes: outputBytes.byteLength,
+			outputSha256: sha256(outputBytes),
+			metadataSizeBytes: metadataBytes.byteLength,
+			metadataSha256: sha256(metadataBytes),
+		};
+
+		// Immutable generations are not visible until the selector is replaced.
+		await this.#store.publishNoReplace(outputFilename, outputBytes);
+		await this.#store.publishNoReplace(metadataFilename, metadataBytes);
+		const stagedOutput = this.#store.readExpected(outputFilename);
+		const stagedMetadata = this.#store.readExpected(metadataFilename);
+		if (
+			!stagedOutput ||
+			!stagedMetadata ||
+			stagedOutput.bytes.byteLength !== generation.outputSizeBytes ||
+			stagedMetadata.bytes.byteLength !== generation.metadataSizeBytes ||
+			sha256(stagedOutput.bytes) !== generation.outputSha256 ||
+			sha256(stagedMetadata.bytes) !== generation.metadataSha256
+		) {
+			throw new Error("managed_output_generation_verification_failed");
+		}
+
+		await this.#store.replace(selectorFilename, Buffer.from(JSON.stringify(generation), "utf8"));
+		const publishedSelector = this.#store.readExpected(selectorFilename);
+		const publishedGeneration = publishedSelector
+			? parseManagedOutputGeneration(publishedSelector.bytes, outputFilenamePrefix)
+			: null;
+		if (!publishedGeneration || !sameGeneration(publishedGeneration, generation)) {
+			throw new Error("managed_output_selector_verification_failed");
+		}
+
+		// Cleanup cannot affect the selected generation or publication outcome.
+		if (priorGeneration && !sameGeneration(priorGeneration, generation)) {
+			for (const filename of [priorGeneration.outputFilename, priorGeneration.metadataFilename]) {
+				try {
+					const previous = this.#store.readExpected(filename);
+					if (previous) this.#store.removeExpected(filename, previous);
+				} catch {
+					// Retain unreachable generations for a later safe cleanup.
+				}
+			}
+		}
+	}
+	async publishNamedNoReplace(filename: string, bytes: Uint8Array): Promise<void> {
+		if (!/^[a-zA-Z0-9_.-]+$/.test(filename)) throw new Error("Unsafe named artifact");
+		await this.#ensureDir();
+		if (this.#store) await this.#store.publishNoReplace(filename, bytes);
+		else await publishManagedFileNoReplace(path.join(this.#dir, filename), bytes);
+	}
+
 	/**
 	 * Scan existing artifact files to find the next available ID.
 	 * This ensures we don't overwrite artifacts when resuming a session.
@@ -81,37 +247,36 @@ export class ArtifactManager {
 	}
 
 	/**
-	 * Allocate a new artifact path and ID without writing content.
+	 * Reserve an artifact ID without exposing a writable managed pathname.
 	 *
-	 * @param toolType Tool name for file extension (e.g., "bash", "read")
+	 * Streaming callers that only understand bare paths fail closed; use `save`
+	 * for terminally published artifact content.
 	 */
-	async allocatePath(toolType: string): Promise<{ id: string; path: string }> {
+	async allocatePath(toolType: string): Promise<{ id: string; path?: string }> {
 		await this.#ensureDir();
 		const id = String(this.allocateId());
-		const filename = `${id}.${toolType}.log`;
-		return { id, path: path.join(this.#dir, filename) };
+		if (this.#store) return { id };
+		return { id, path: path.join(this.#dir, this.#filename(id, toolType)) };
 	}
 
 	/**
 	 * Save content as an artifact and return the artifact ID.
-	 *
-	 * @param content Full content to save
-	 * @param toolType Tool name for file extension (e.g., "bash", "read")
-	 * @returns Artifact ID (numeric string)
+	 * Content is written to a private temporary inode, synced, and linked into
+	 * the artifact directory only after the complete terminal payload exists.
 	 */
 	async save(content: string, toolType: string, options: ArtifactSaveOptions = {}): Promise<string> {
-		const { id, path } = await this.allocatePath(toolType);
+		await this.#ensureDir();
+		const id = String(this.allocateId());
 		const maxBytes = Math.max(0, options.maxBytes ?? DEFAULT_ARTIFACT_MAX_BYTES);
 		const contentBytes = Buffer.byteLength(content, "utf-8");
-		if (contentBytes > maxBytes) {
-			const truncated = truncateHeadBytes(content, maxBytes);
-			await Bun.write(
-				path,
-				`${truncated.text}\n[artifact truncated after ${truncated.bytes} bytes; omitted at least ${contentBytes - truncated.bytes} bytes]\n`,
-			);
-		} else {
-			await Bun.write(path, content);
-		}
+		const published =
+			contentBytes > maxBytes
+				? (() => {
+						const truncated = truncateHeadBytes(content, maxBytes);
+						return `${truncated.text}\n[artifact truncated after ${truncated.bytes} bytes; omitted at least ${contentBytes - truncated.bytes} bytes]\n`;
+					})()
+				: content;
+		await this.#publish(published, this.#filename(id, toolType));
 		return id;
 	}
 

package/src/session/context-estimation.ts

@@ -7,6 +7,7 @@
  * as well, so every surface reports the same numbers.
  */
 import { estimateTextTokensHeuristic } from "@gajae-code/agent-core/compaction";
+import { toolWireSchema } from "@gajae-code/ai/utils/schema/wire";
 import type { Skill } from "../extensibility/skills";
 import type { Tool } from "../tools";
 import type { AgentSession } from "./agent-session";
@@ -28,9 +29,13 @@ export function estimateToolSchemaTokens(
 	for (const tool of tools) {
 		fragments.push(tool.name, tool.description);
 		try {
-			fragments.push(JSON.stringify(tool.parameters ?? {}));
+			fragments.push(JSON.stringify(toolWireSchema(tool as never)));
 		} catch {
-			// Schema may contain functions or cycles; ignore.
+			try {
+				fragments.push(JSON.stringify(tool.parameters ?? {}));
+			} catch {
+				// Schema may contain functions or cycles; ignore.
+			}
 		}
 	}
 	return estimateTextTokensHeuristic(fragments);