@vimhead.dev/norn-cli 0.1.0-tip.35614826665.1 → 0.1.0-tip.35724621678.1

package/assets/packages/cli/src/internal/run-store.ts

@@ -1,12 +1,29 @@
 import { createHash, randomUUID } from "node:crypto";
 import { constants } from "node:fs";
-import { access, chmod, lstat, mkdir, mkdtemp, readFile, readdir, readlink, rename, rm, symlink, utimes, writeFile } from "node:fs/promises";
+import {
+	access,
+	chmod,
+	lstat,
+	mkdir,
+	mkdtemp,
+	readFile,
+	readdir,
+	readlink,
+	rename,
+	rm,
+	symlink,
+	utimes,
+	writeFile,
+} from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 import { gunzip, gzip } from "node:zlib";
 import type { NornRunCheckpoint } from "@vimhead.dev/norn";
 import { isNodeError } from "@vimhead.dev/norn-core/errors";
-import { writeJsonAtomically, writeTextAtomically } from "@vimhead.dev/norn-core/atomic-files";
+import {
+	writeJsonAtomically,
+	writeTextAtomically,
+} from "@vimhead.dev/norn-core/atomic-files";
 
 const gzipBuffer = promisify(gzip);
 const gunzipBuffer = promisify(gunzip);
@@ -50,42 +67,62 @@ export class NornRunStore {
 
 	async snapshotCurrent(message: string): Promise<NornRunCheckpoint> {
 		const previous = await this.readCheckpointHistory();
-		const checkpoint = this.createCheckpoint(message, previous.checkpoints.length + 1);
+		const checkpoint = this.createCheckpoint(
+			message,
+			previous.checkpoints.length + 1,
+		);
 		const checkpoints = [...previous.checkpoints, checkpoint];
 		await this.createSnapshot(checkpoint, checkpoints);
 		await writeJsonAtomically(this.checkpointsPath, checkpoints);
 		try {
 			await writeTextAtomically(this.currentRefPath, `${checkpoint.id}\n`);
 		} catch (error) {
-			if (previous.content === undefined) await rm(this.checkpointsPath, { force: true });
+			if (previous.content === undefined)
+				await rm(this.checkpointsPath, { force: true });
 			else await writeTextAtomically(this.checkpointsPath, previous.content);
 			throw error;
 		}
 		return checkpoint;
 	}
 
-	async restoreSnapshot(ref: string, prepare: ((stagedRunRoot: string) => Promise<void>) | undefined): Promise<void> {
-		const checkpoint = (await this.listCheckpoints()).find((entry) => entry.id === ref);
+	async restoreSnapshot(
+		ref: string,
+		prepare: ((stagedRunRoot: string) => Promise<void>) | undefined,
+	): Promise<void> {
+		const checkpoint = (await this.listCheckpoints()).find(
+			(entry) => entry.id === ref,
+		);
 		if (!checkpoint) throw new Error(`Unknown active run checkpoint: ${ref}`);
-		await this.restoreSnapshotManifest(await this.readSnapshot(checkpoint.id), prepare);
+		await this.restoreSnapshotManifest(
+			await this.readSnapshot(checkpoint.id),
+			prepare,
+		);
 	}
 
 	async restoreCurrentSnapshot(): Promise<void> {
-		await this.restoreSnapshotManifest(await this.readSnapshot(await this.currentSnapshotRef()), undefined);
+		await this.restoreSnapshotManifest(
+			await this.readSnapshot(await this.currentSnapshotRef()),
+			undefined,
+		);
 	}
 
 	async listCheckpoints(): Promise<NornRunCheckpoint[]> {
 		return (await this.readCheckpointHistory()).checkpoints;
 	}
 
-	private async readCheckpointHistory(): Promise<{ readonly checkpoints: NornRunCheckpoint[]; readonly content?: string }> {
+	private async readCheckpointHistory(): Promise<{
+		readonly checkpoints: NornRunCheckpoint[];
+		readonly content?: string;
+	}> {
 		try {
 			const content = await readFile(this.checkpointsPath, "utf8");
 			const checkpoints = parseNornRunCheckpoints(JSON.parse(content));
-			for (const checkpoint of checkpoints) this.assertCheckpointPathMatchesId(checkpoint);
+			for (const checkpoint of checkpoints)
+				this.assertCheckpointPathMatchesId(checkpoint);
 			return { checkpoints, content };
 		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return { checkpoints: [] };
+			if (isNodeError(error) && error.code === "ENOENT")
+				return { checkpoints: [] };
 			throw error;
 		}
 	}
@@ -114,15 +151,36 @@ export class NornRunStore {
 
 	private createCheckpoint(message: string, index: number): NornRunCheckpoint {
 		const id = `cp_${randomUUID().replaceAll("-", "")}`;
-		return { id, path: this.snapshotRelativePath(id), index, message, createdAt: new Date().toISOString() };
+		return {
+			id,
+			path: this.snapshotRelativePath(id),
+			index,
+			message,
+			createdAt: new Date().toISOString(),
+		};
 	}
 
-	private async createSnapshot(checkpoint: NornRunCheckpoint, checkpoints: readonly NornRunCheckpoint[]): Promise<RunSnapshotManifest> {
-		const entries = (await this.snapshotEntries(this.currentRoot)).filter((entry) => entry.path !== CHECKPOINTS_FILE_NAME);
-		const historyBytes = Buffer.from(`${JSON.stringify(checkpoints, null, 2)}\n`);
+	private async createSnapshot(
+		checkpoint: NornRunCheckpoint,
+		checkpoints: readonly NornRunCheckpoint[],
+	): Promise<RunSnapshotManifest> {
+		const entries = (await this.snapshotEntries(this.currentRoot)).filter(
+			(entry) => entry.path !== CHECKPOINTS_FILE_NAME,
+		);
+		const historyBytes = Buffer.from(
+			`${JSON.stringify(checkpoints, null, 2)}\n`,
+		);
 		const historyHash = hashBuffer(historyBytes);
 		await this.storeObject(historyHash, historyBytes);
-		entries.push({ path: CHECKPOINTS_FILE_NAME, type: "file", sha256: historyHash, size: historyBytes.length, mode: 0o600, mtimeMs: Date.now(), compression: "gzip" });
+		entries.push({
+			path: CHECKPOINTS_FILE_NAME,
+			type: "file",
+			sha256: historyHash,
+			size: historyBytes.length,
+			mode: 0o600,
+			mtimeMs: Date.now(),
+			compression: "gzip",
+		});
 		entries.sort((left, right) => left.path.localeCompare(right.path));
 		const snapshot: RunSnapshotManifest = {
 			version: SNAPSHOT_VERSION,
@@ -143,25 +201,52 @@ export class NornRunStore {
 		return entries.sort((left, right) => left.path.localeCompare(right.path));
 	}
 
-	private async collectSnapshotEntries(absolutePath: string, snapshotPath: string, entries: RunSnapshotEntry[]): Promise<void> {
+	private async collectSnapshotEntries(
+		absolutePath: string,
+		snapshotPath: string,
+		entries: RunSnapshotEntry[],
+	): Promise<void> {
 		const stat = await lstat(absolutePath);
 		if (stat.isDirectory()) {
-			if (snapshotPath.length > 0) entries.push({ path: snapshotPath, type: "directory", mode: stat.mode });
+			if (snapshotPath.length > 0)
+				entries.push({
+					path: snapshotPath,
+					type: "directory",
+					mode: stat.mode,
+				});
 			const children = await readdir(absolutePath, { withFileTypes: true });
-			for (const child of children.sort((left, right) => left.name.localeCompare(right.name))) {
-				await this.collectSnapshotEntries(join(absolutePath, child.name), joinSnapshotPath(snapshotPath, child.name), entries);
+			for (const child of children.sort((left, right) =>
+				left.name.localeCompare(right.name),
+			)) {
+				await this.collectSnapshotEntries(
+					join(absolutePath, child.name),
+					joinSnapshotPath(snapshotPath, child.name),
+					entries,
+				);
 			}
 			return;
 		}
 		if (stat.isSymbolicLink()) {
-			entries.push({ path: snapshotPath, type: "symlink", target: await readlink(absolutePath) });
+			entries.push({
+				path: snapshotPath,
+				type: "symlink",
+				target: await readlink(absolutePath),
+			});
 			return;
 		}
 		if (!stat.isFile()) return;
 		const bytes = await readFile(absolutePath);
 		const sha256 = hashBuffer(bytes);
 		await this.storeObject(sha256, bytes);
-		entries.push({ path: snapshotPath, type: "file", sha256, size: stat.size, mode: stat.mode, mtimeMs: stat.mtimeMs, compression: "gzip" });
+		entries.push({
+			path: snapshotPath,
+			type: "file",
+			sha256,
+			size: stat.size,
+			mode: stat.mode,
+			mtimeMs: stat.mtimeMs,
+			compression: "gzip",
+		});
 	}
 
 	private async storeObject(sha256: string, bytes: Buffer): Promise<void> {
@@ -178,7 +263,10 @@ export class NornRunStore {
 		await rename(tmpPath, path);
 	}
 
-	private async restoreSnapshotManifest(snapshot: RunSnapshotManifest, prepare: ((stagedRunRoot: string) => Promise<void>) | undefined): Promise<void> {
+	private async restoreSnapshotManifest(
+		snapshot: RunSnapshotManifest,
+		prepare: ((stagedRunRoot: string) => Promise<void>) | undefined,
+	): Promise<void> {
 		const stagedRunRoot = await mkdtemp(join(this.runRoot, ".restore-"));
 		const stagedCurrent = runCurrentRoot(stagedRunRoot);
 		const previousCurrent = join(this.runRoot, `.previous-${randomUUID()}`);
@@ -200,26 +288,38 @@ export class NornRunStore {
 				await rename(previousCurrent, this.currentRoot);
 				throw error;
 			}
-			await rm(previousCurrent, { recursive: true, force: true }).catch(() => undefined);
+			await rm(previousCurrent, { recursive: true, force: true }).catch(
+				() => undefined,
+			);
 		} finally {
-			await rm(stagedRunRoot, { recursive: true, force: true }).catch(() => undefined);
+			await rm(stagedRunRoot, { recursive: true, force: true }).catch(
+				() => undefined,
+			);
 		}
 	}
 
-	private async materializeSnapshot(snapshot: RunSnapshotManifest, destination: string): Promise<void> {
+	private async materializeSnapshot(
+		snapshot: RunSnapshotManifest,
+		destination: string,
+	): Promise<void> {
 		const entriesByPath = new Map<string, RunSnapshotEntry>();
 		for (const entry of snapshot.entries) {
 			this.materializedPath(destination, entry.path);
-			if (entriesByPath.has(entry.path)) throw new Error(`Duplicate snapshot path: ${entry.path}`);
+			if (entriesByPath.has(entry.path))
+				throw new Error(`Duplicate snapshot path: ${entry.path}`);
 			entriesByPath.set(entry.path, entry);
 		}
 		for (const entry of snapshot.entries) {
 			let parent = dirname(entry.path);
 			while (parent !== ".") {
-				if (entriesByPath.get(parent)?.type !== "directory") throw new Error(`Snapshot parent is not a directory: ${parent}`);
+				if (entriesByPath.get(parent)?.type !== "directory")
+					throw new Error(`Snapshot parent is not a directory: ${parent}`);
 				parent = dirname(parent);
 			}
-			if (entry.type === "directory") await mkdir(this.materializedPath(destination, entry.path), { recursive: true });
+			if (entry.type === "directory")
+				await mkdir(this.materializedPath(destination, entry.path), {
+					recursive: true,
+				});
 		}
 		for (const entry of snapshot.entries) {
 			if (entry.type === "directory") continue;
@@ -228,28 +328,44 @@ export class NornRunStore {
 				await symlink(entry.target, path);
 				continue;
 			}
-			const bytes = await gunzipBuffer(await readFile(this.objectPath(entry.sha256)));
+			const bytes = await gunzipBuffer(
+				await readFile(this.objectPath(entry.sha256)),
+			);
 			const actualSha256 = hashBuffer(bytes);
-			if (actualSha256 !== entry.sha256) throw new Error(`CAS object checksum mismatch: ${entry.sha256}`);
+			if (actualSha256 !== entry.sha256)
+				throw new Error(`CAS object checksum mismatch: ${entry.sha256}`);
 			await writeFile(path, bytes);
 			await chmod(path, entry.mode);
 			await utimes(path, new Date(entry.mtimeMs), new Date(entry.mtimeMs));
 		}
 		for (const entry of [...snapshot.entries].reverse()) {
-			if (entry.type === "directory") await chmod(this.materializedPath(destination, entry.path), entry.mode);
+			if (entry.type === "directory")
+				await chmod(this.materializedPath(destination, entry.path), entry.mode);
 		}
 	}
 
 	private materializedPath(destination: string, snapshotPath: string): string {
-		if (snapshotPath.length === 0 || isAbsolute(snapshotPath) || snapshotPath.split(/[\\/]/).some((part) => part === ".." || part === "." || part === "")) throw new Error(`Invalid snapshot path: ${snapshotPath}`);
+		if (
+			snapshotPath.length === 0 ||
+			isAbsolute(snapshotPath) ||
+			snapshotPath
+				.split(/[\\/]/)
+				.some((part) => part === ".." || part === "." || part === "")
+		)
+			throw new Error(`Invalid snapshot path: ${snapshotPath}`);
 		const path = resolve(destination, ...snapshotPath.split("/"));
 		const pathFromCurrent = relative(destination, path);
-		if (pathFromCurrent === ".." || pathFromCurrent.startsWith(`..${sep}`)) throw new Error(`Snapshot path escapes current checkout: ${snapshotPath}`);
+		if (pathFromCurrent === ".." || pathFromCurrent.startsWith(`..${sep}`))
+			throw new Error(
+				`Snapshot path escapes current checkout: ${snapshotPath}`,
+			);
 		return path;
 	}
 
 	private async readSnapshot(id: string): Promise<RunSnapshotManifest> {
-		return parseRunSnapshotManifest(JSON.parse(await readFile(this.snapshotPath(id), "utf8")));
+		return parseRunSnapshotManifest(
+			JSON.parse(await readFile(this.snapshotPath(id), "utf8")),
+		);
 	}
 
 	private snapshotPath(id: string): string {
@@ -262,11 +378,19 @@ export class NornRunStore {
 
 	private assertCheckpointPathMatchesId(checkpoint: NornRunCheckpoint): void {
 		const expectedPath = this.snapshotRelativePath(checkpoint.id);
-		if (checkpoint.path !== expectedPath) throw new Error(`Run checkpoint path does not match id: ${checkpoint.id}`);
+		if (checkpoint.path !== expectedPath)
+			throw new Error(
+				`Run checkpoint path does not match id: ${checkpoint.id}`,
+			);
 	}
 
 	private objectPath(sha256: string): string {
-		return join(this.objectsRoot, sha256.slice(0, 2), sha256.slice(2, 4), `${sha256}.gz`);
+		return join(
+			this.objectsRoot,
+			sha256.slice(0, 2),
+			sha256.slice(2, 4),
+			`${sha256}.gz`,
+		);
 	}
 }
 
@@ -282,8 +406,20 @@ type RunSnapshotManifest = {
 
 type RunSnapshotEntry =
 	| { readonly path: string; readonly type: "directory"; readonly mode: number }
-	| { readonly path: string; readonly type: "file"; readonly sha256: string; readonly size: number; readonly mode: number; readonly mtimeMs: number; readonly compression: "gzip" }
-	| { readonly path: string; readonly type: "symlink"; readonly target: string };
+	| {
+			readonly path: string;
+			readonly type: "file";
+			readonly sha256: string;
+			readonly size: number;
+			readonly mode: number;
+			readonly mtimeMs: number;
+			readonly compression: "gzip";
+	  }
+	| {
+			readonly path: string;
+			readonly type: "symlink";
+			readonly target: string;
+	  };
 
 function hashBuffer(bytes: Buffer): string {
 	return createHash("sha256").update(bytes).digest("hex");
@@ -294,14 +430,27 @@ function joinSnapshotPath(parent: string, child: string): string {
 }
 
 function parseRunSnapshotManifest(value: unknown): RunSnapshotManifest {
-	if (!value || typeof value !== "object") throw new Error("Invalid run snapshot manifest");
+	if (!value || typeof value !== "object")
+		throw new Error("Invalid run snapshot manifest");
 	const snapshot = value as Partial<RunSnapshotManifest>;
-	if (snapshot.version !== SNAPSHOT_VERSION) throw new Error(`Unsupported run snapshot version: ${String(snapshot.version)}`);
-	if (typeof snapshot.id !== "string" || snapshot.id.length === 0) throw new Error("Invalid run snapshot id");
-	if (typeof snapshot.index !== "number" || !Number.isInteger(snapshot.index) || snapshot.index < 1) throw new Error("Invalid run snapshot index");
-	if (typeof snapshot.message !== "string") throw new Error("Invalid run snapshot message");
-	if (typeof snapshot.createdAt !== "string") throw new Error("Invalid run snapshot timestamp");
-	if (!Array.isArray(snapshot.entries)) throw new Error("Invalid run snapshot entries");
+	if (snapshot.version !== SNAPSHOT_VERSION)
+		throw new Error(
+			`Unsupported run snapshot version: ${String(snapshot.version)}`,
+		);
+	if (typeof snapshot.id !== "string" || snapshot.id.length === 0)
+		throw new Error("Invalid run snapshot id");
+	if (
+		typeof snapshot.index !== "number" ||
+		!Number.isInteger(snapshot.index) ||
+		snapshot.index < 1
+	)
+		throw new Error("Invalid run snapshot index");
+	if (typeof snapshot.message !== "string")
+		throw new Error("Invalid run snapshot message");
+	if (typeof snapshot.createdAt !== "string")
+		throw new Error("Invalid run snapshot timestamp");
+	if (!Array.isArray(snapshot.entries))
+		throw new Error("Invalid run snapshot entries");
 	return snapshot as RunSnapshotManifest;
 }
 
@@ -311,13 +460,27 @@ function parseNornRunCheckpoints(value: unknown): NornRunCheckpoint[] {
 }
 
 function parseNornRunCheckpoint(value: unknown): NornRunCheckpoint {
-	if (!value || typeof value !== "object") throw new Error("Invalid run checkpoint");
+	if (!value || typeof value !== "object")
+		throw new Error("Invalid run checkpoint");
 	const checkpoint = value as Partial<NornRunCheckpoint>;
-	if (typeof checkpoint.id !== "string" || checkpoint.id.length === 0) throw new Error("Invalid run checkpoint id");
-	if (typeof checkpoint.path !== "string" || checkpoint.path.length === 0) throw new Error("Invalid run checkpoint path");
-	if (checkpoint.path.split(/[\\/]/).includes("..") || resolve(checkpoint.path) === checkpoint.path) throw new Error(`Invalid run checkpoint path: ${checkpoint.path}`);
-	if (typeof checkpoint.index !== "number" || !Number.isInteger(checkpoint.index) || checkpoint.index < 1) throw new Error("Invalid run checkpoint index");
-	if (typeof checkpoint.message !== "string") throw new Error("Invalid run checkpoint message");
-	if (typeof checkpoint.createdAt !== "string") throw new Error("Invalid run checkpoint timestamp");
+	if (typeof checkpoint.id !== "string" || checkpoint.id.length === 0)
+		throw new Error("Invalid run checkpoint id");
+	if (typeof checkpoint.path !== "string" || checkpoint.path.length === 0)
+		throw new Error("Invalid run checkpoint path");
+	if (
+		checkpoint.path.split(/[\\/]/).includes("..") ||
+		resolve(checkpoint.path) === checkpoint.path
+	)
+		throw new Error(`Invalid run checkpoint path: ${checkpoint.path}`);
+	if (
+		typeof checkpoint.index !== "number" ||
+		!Number.isInteger(checkpoint.index) ||
+		checkpoint.index < 1
+	)
+		throw new Error("Invalid run checkpoint index");
+	if (typeof checkpoint.message !== "string")
+		throw new Error("Invalid run checkpoint message");
+	if (typeof checkpoint.createdAt !== "string")
+		throw new Error("Invalid run checkpoint timestamp");
 	return checkpoint as NornRunCheckpoint;
 }

package/assets/packages/cli/src/internal/usage.ts

@@ -1,6 +1,8 @@
 import type { NornAgentUsage } from "@vimhead.dev/norn";
 
-export function agentUsageFromValue(value: unknown): NornAgentUsage | undefined {
+export function agentUsageFromValue(
+	value: unknown,
+): NornAgentUsage | undefined {
 	if (!value || typeof value !== "object") return undefined;
 	const usage = value as Record<string, unknown>;
 	const input = numberField(usage.input);
@@ -8,8 +10,12 @@ export function agentUsageFromValue(value: unknown): NornAgentUsage | undefined
 	const cacheRead = numberField(usage.cacheRead);
 	const cacheWrite = numberField(usage.cacheWrite);
 	const reasoning = optionalNumberField(usage.reasoning);
-	const totalTokens = numberField(usage.totalTokens) || input + output + cacheRead + cacheWrite;
-	const costValue = usage.cost && typeof usage.cost === "object" ? usage.cost as Record<string, unknown> : {};
+	const totalTokens =
+		numberField(usage.totalTokens) || input + output + cacheRead + cacheWrite;
+	const costValue =
+		usage.cost && typeof usage.cost === "object"
+			? (usage.cost as Record<string, unknown>)
+			: {};
 	return {
 		input,
 		output,
@@ -27,12 +33,20 @@ export function agentUsageFromValue(value: unknown): NornAgentUsage | undefined
 	};
 }
 
-export function totalAgentUsage(usages: readonly NornAgentUsage[]): NornAgentUsage {
+export function totalAgentUsage(
+	usages: readonly NornAgentUsage[],
+): NornAgentUsage {
 	return usages.reduce(addAgentUsage, emptyAgentUsage());
 }
 
-export function addAgentUsage(left: NornAgentUsage, right: NornAgentUsage): NornAgentUsage {
-	const reasoning = left.reasoning === undefined && right.reasoning === undefined ? undefined : (left.reasoning ?? 0) + (right.reasoning ?? 0);
+export function addAgentUsage(
+	left: NornAgentUsage,
+	right: NornAgentUsage,
+): NornAgentUsage {
+	const reasoning =
+		left.reasoning === undefined && right.reasoning === undefined
+			? undefined
+			: (left.reasoning ?? 0) + (right.reasoning ?? 0);
 	return {
 		input: left.input + right.input,
 		output: left.output + right.output,
@@ -66,5 +80,7 @@ function numberField(value: unknown): number {
 }
 
 function optionalNumberField(value: unknown): number | undefined {
-	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+	return typeof value === "number" && Number.isFinite(value)
+		? value
+		: undefined;
 }

package/assets/packages/cli/src/internal/worker-directory.ts

@@ -2,7 +2,9 @@ import { chmod, lstat, mkdir, readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { isNodeError } from "@vimhead.dev/norn-core/errors";
 
-export async function prepareRunWorkerDirectory(runRoot: string): Promise<string> {
+export async function prepareRunWorkerDirectory(
+	runRoot: string,
+): Promise<string> {
 	const directory = join(runRoot, "worker");
 	try {
 		await mkdir(directory, { mode: 0o555 });
@@ -10,8 +12,12 @@ export async function prepareRunWorkerDirectory(runRoot: string): Promise<string
 		if (!isNodeError(error) || error.code !== "EEXIST") throw error;
 	}
 	const metadata = await lstat(directory);
-	if (!metadata.isDirectory() || metadata.isSymbolicLink()) throw new Error(`Run worker cwd must be a directory, not a symlink: ${directory}`);
-	if ((await readdir(directory)).length !== 0) throw new Error(`Run worker cwd must be empty: ${directory}`);
+	if (!metadata.isDirectory() || metadata.isSymbolicLink())
+		throw new Error(
+			`Run worker cwd must be a directory, not a symlink: ${directory}`,
+		);
+	if ((await readdir(directory)).length !== 0)
+		throw new Error(`Run worker cwd must be empty: ${directory}`);
 	await chmod(directory, 0o555);
 	return directory;
 }