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

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

@@ -6,11 +6,16 @@ export class NornProjectLoadError extends Error {
 	readonly isComplete = false;
 	readonly diagnostics: readonly NornWorkflowDiagnostic[];
 
-	constructor(input: { readonly diagnostics: readonly NornWorkflowDiagnostic[] }) {
-		const details = input.diagnostics.map(diagnostic =>
-			`${diagnostic.stage}: ${diagnostic.modulePath} (declared in ${diagnostic.configPath}${diagnostic.workflowId ? `; workflow ${diagnostic.workflowId}` : ""}): ${diagnostic.message}`,
+	constructor(input: {
+		readonly diagnostics: readonly NornWorkflowDiagnostic[];
+	}) {
+		const details = input.diagnostics.map(
+			(diagnostic) =>
+				`${diagnostic.stage}: ${diagnostic.modulePath} (declared in ${diagnostic.configPath}${diagnostic.workflowId ? `; workflow ${diagnostic.workflowId}` : ""}): ${diagnostic.message}`,
+		);
+		super(
+			`Norn project is incomplete (${input.diagnostics.length} diagnostics); execution is blocked.\n${details.join("\n")}`,
 		);
-		super(`Norn project is incomplete (${input.diagnostics.length} diagnostics); execution is blocked.\n${details.join("\n")}`);
 		this.name = "NornProjectLoadError";
 		this.diagnostics = input.diagnostics;
 	}
@@ -24,7 +29,10 @@ export class NornRunStoppedError extends Error {
 }
 
 export function schemaErrorMessage(error: AssertError): string {
-	return error.cause.errors.slice(0, 3).map(issue => `${issue.instancePath || "/"}: ${issue.message}`).join("; ");
+	return error.cause.errors
+		.slice(0, 3)
+		.map((issue) => `${issue.instancePath || "/"}: ${issue.message}`)
+		.join("; ");
 }
 
 export function errorMessage(error: unknown): string {

package/assets/packages/cli/src/internal/execution-context.ts

@@ -1,5 +1,10 @@
 import type { CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
-import type { NornAgents, NornCommands, NornLogs, NornRun } from "@vimhead.dev/norn";
+import type {
+	NornAgents,
+	NornCommands,
+	NornLogs,
+	NornRun,
+} from "@vimhead.dev/norn";
 import { createWorkflowTransition } from "@vimhead.dev/norn-core/workflow-transition";
 import type { NornAgentResponseCollector } from "./agent-response-tool.ts";
 import { NornAgentRunner } from "./agents.ts";
@@ -28,23 +33,26 @@ export class NornExecutionContext {
 	constructor(private readonly input: NornExecutionContextInput) {
 		this.run = {
 			id: input.id,
-			next: (workflowId, args) => createWorkflowTransition({ workflowId, args }),
-			complete: metadata => ({ type: "complete", metadata }),
-			fail: metadata => ({ type: "fail", metadata }),
+			next: (workflowId, args) =>
+				createWorkflowTransition({ workflowId, args }),
+			complete: (metadata) => ({ type: "complete", metadata }),
+			fail: (metadata) => ({ type: "fail", metadata }),
 		};
 		this.logs = {
-			read: log => this.input.logs.read(log),
+			read: (log) => this.input.logs.read(log),
 		};
 		this.commands = {
-			run: commandInput => new NornCommandRunner({
-				signal: this.input.signal,
-				logs: this.input.logs,
-				logger: this.input.logger,
-			}).run(commandInput),
+			run: (commandInput) =>
+				new NornCommandRunner({
+					signal: this.input.signal,
+					logs: this.input.logs,
+					logger: this.input.logger,
+				}).run(commandInput),
 		};
 		this.agents = {
-			createSession: agentInput => this.createAgentRunner().createSession(agentInput),
-			prompt: agentInput => this.createAgentRunner().prompt(agentInput),
+			createSession: (agentInput) =>
+				this.createAgentRunner().createSession(agentInput),
+			prompt: (agentInput) => this.createAgentRunner().prompt(agentInput),
 		};
 	}
 

package/assets/packages/cli/src/internal/file-coordinator.ts

@@ -1,29 +1,53 @@
 import { writeTextAtomically } from "@vimhead.dev/norn-core/atomic-files";
 import { isNodeError } from "@vimhead.dev/norn-core/errors";
 import { createHash, randomUUID } from "node:crypto";
-import { lstat, mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, rmdir, unlink, writeFile } from "node:fs/promises";
+import {
+	lstat,
+	mkdir,
+	mkdtemp,
+	readFile,
+	readdir,
+	realpath,
+	rename,
+	rm,
+	rmdir,
+	unlink,
+	writeFile,
+} from "node:fs/promises";
 import { hostname } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 
-const ownerSchema = Type.Object({
-	token: Type.String({ format: "uuid" }),
-	pid: Type.Integer({ exclusiveMinimum: 0 }),
-	host: Type.String(),
-	target: Type.String(),
-}, { additionalProperties: false });
+const ownerSchema = Type.Object(
+	{
+		token: Type.String({ format: "uuid" }),
+		pid: Type.Integer({ exclusiveMinimum: 0 }),
+		host: Type.String(),
+		target: Type.String(),
+	},
+	{ additionalProperties: false },
+);
 
 export class NornFileCoordinator {
 	private readonly lockRoot: string;
 
-	constructor(private readonly input: { readonly lockRoot: string; readonly waitTimeoutMs: number }) {
-		if (!Number.isSafeInteger(input.waitTimeoutMs) || input.waitTimeoutMs <= 0) throw new Error("Lock wait timeout must be a positive integer");
+	constructor(
+		private readonly input: {
+			readonly lockRoot: string;
+			readonly waitTimeoutMs: number;
+		},
+	) {
+		if (!Number.isSafeInteger(input.waitTimeoutMs) || input.waitTimeoutMs <= 0)
+			throw new Error("Lock wait timeout must be a positive integer");
 		this.lockRoot = resolve(input.lockRoot);
 	}
 
-	async withExclusiveLock<T>(path: string, operation: (lockedPath: string) => Promise<T>): Promise<T> {
+	async withExclusiveLock<T>(
+		path: string,
+		operation: (lockedPath: string) => Promise<T>,
+	): Promise<T> {
 		const target = await this.resolveTarget(path);
 		await mkdir(this.lockRoot, { recursive: true, mode: 0o700 });
 		const key = createHash("sha256").update(target).digest("hex");
@@ -33,7 +57,11 @@ export class NornFileCoordinator {
 		const marker = `${token}.json`;
 		return this.withCleanup({
 			operation: async () => {
-				await writeFile(join(stagingPath, marker), JSON.stringify({ token, pid: process.pid, host: hostname(), target }), { mode: 0o600 });
+				await writeFile(
+					join(stagingPath, marker),
+					JSON.stringify({ token, pid: process.pid, host: hostname(), target }),
+					{ mode: 0o600 },
+				);
 				await this.acquire({ stagingPath, lockPath, target });
 				return this.withCleanup({
 					operation: () => operation(target),
@@ -48,21 +76,34 @@ export class NornFileCoordinator {
 	}
 
 	async readText(path: string): Promise<string> {
-		return this.withExclusiveLock(path, (lockedPath) => readFile(lockedPath, "utf8"));
+		return this.withExclusiveLock(path, (lockedPath) =>
+			readFile(lockedPath, "utf8"),
+		);
 	}
 
 	async writeText(path: string, content: string): Promise<void> {
 		await mkdir(dirname(path), { recursive: true });
-		await this.withExclusiveLock(path, (lockedPath) => writeTextAtomically(lockedPath, content));
+		await this.withExclusiveLock(path, (lockedPath) =>
+			writeTextAtomically(lockedPath, content),
+		);
 	}
 
-	private async withCleanup<T>(input: { readonly operation: () => Promise<T>; readonly cleanup: () => Promise<void> }): Promise<T> {
+	private async withCleanup<T>(input: {
+		readonly operation: () => Promise<T>;
+		readonly cleanup: () => Promise<void>;
+	}): Promise<T> {
 		let result: T;
 		try {
 			result = await input.operation();
 		} catch (error) {
-			try { await input.cleanup(); }
-			catch (cleanupError) { throw new AggregateError([error, cleanupError], "File operation and lock cleanup failed"); }
+			try {
+				await input.cleanup();
+			} catch (cleanupError) {
+				throw new AggregateError(
+					[error, cleanupError],
+					"File operation and lock cleanup failed",
+				);
+			}
 			throw error;
 		}
 		await input.cleanup();
@@ -78,34 +119,55 @@ export class NornFileCoordinator {
 				if (isNodeError(error) && error.code === "ENOENT") return undefined;
 				throw error;
 			});
-			if (entry?.isSymbolicLink()) throw new Error(`Cannot lock a dangling symbolic link: ${path}`);
+			if (entry?.isSymbolicLink())
+				throw new Error(`Cannot lock a dangling symbolic link: ${path}`);
 			return join(await realpath(dirname(path)), basename(path));
 		}
 	}
 
-	private async acquire(input: { readonly stagingPath: string; readonly lockPath: string; readonly target: string }): Promise<void> {
+	private async acquire(input: {
+		readonly stagingPath: string;
+		readonly lockPath: string;
+		readonly target: string;
+	}): Promise<void> {
 		const deadline = Date.now() + this.input.waitTimeoutMs;
 		while (true) {
 			try {
 				await rename(input.stagingPath, input.lockPath);
 				return;
 			} catch (error) {
-				if (!isNodeError(error) || !["ENOTEMPTY", "EEXIST"].includes(error.code ?? "")) throw error;
+				if (
+					!isNodeError(error) ||
+					!["ENOTEMPTY", "EEXIST"].includes(error.code ?? "")
+				)
+					throw error;
 			}
 			await this.reclaimDeadOwner(input);
-			if (Date.now() >= deadline) throw new Error(`Timed out waiting for file lock: ${input.target}`);
+			if (Date.now() >= deadline)
+				throw new Error(`Timed out waiting for file lock: ${input.target}`);
 			await delay(10);
 		}
 	}
 
-	private async reclaimDeadOwner(input: { readonly lockPath: string; readonly target: string }): Promise<void> {
+	private async reclaimDeadOwner(input: {
+		readonly lockPath: string;
+		readonly target: string;
+	}): Promise<void> {
 		try {
 			const entries = await readdir(input.lockPath);
 			if (entries.length === 0) return;
-			if (entries.length !== 1) throw new Error(`Invalid file lock ownership: ${input.lockPath}`);
+			if (entries.length !== 1)
+				throw new Error(`Invalid file lock ownership: ${input.lockPath}`);
 			const marker = entries[0];
-			const owner = Value.Parse(ownerSchema, JSON.parse(await readFile(join(input.lockPath, marker), "utf8")));
-			if (marker !== `${owner.token}.json` || owner.target !== input.target || owner.host !== hostname()) {
+			const owner = Value.Parse(
+				ownerSchema,
+				JSON.parse(await readFile(join(input.lockPath, marker), "utf8")),
+			);
+			if (
+				marker !== `${owner.token}.json` ||
+				owner.target !== input.target ||
+				owner.host !== hostname()
+			) {
 				throw new Error(`Incompatible file lock ownership: ${input.lockPath}`);
 			}
 			try {
@@ -127,11 +189,18 @@ export class NornFileCoordinator {
 		try {
 			await rmdir(path);
 		} catch (error) {
-			if (!isNodeError(error) || !["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code ?? "")) throw error;
+			if (
+				!isNodeError(error) ||
+				!["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code ?? "")
+			)
+				throw error;
 		}
 	}
 }
 
 export function createRunFileCoordinator(runRoot: string): NornFileCoordinator {
-	return new NornFileCoordinator({ lockRoot: join(runRoot, "locks"), waitTimeoutMs: 30_000 });
+	return new NornFileCoordinator({
+		lockRoot: join(runRoot, "locks"),
+		waitTimeoutMs: 30_000,
+	});
 }

package/assets/packages/cli/src/internal/file-names.ts

@@ -1,3 +1,6 @@
 export function safeFileName(value: string): string {
-	return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "workflow";
+	return (
+		value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") ||
+		"workflow"
+	);
 }

package/assets/packages/cli/src/internal/launch-request.ts

@@ -29,15 +29,25 @@ export type NornRunResumeRequest = {
 	readonly createdAt: string;
 };
 
-export async function writeRunLaunchRequest(runRoot: string, request: NornRunLaunchRequest): Promise<void> {
+export async function writeRunLaunchRequest(
+	runRoot: string,
+	request: NornRunLaunchRequest,
+): Promise<void> {
 	await writeJsonAtomically(join(runRoot, LAUNCH_REQUEST_FILE_NAME), request);
 }
 
-export async function readRunLaunchRequest(runRoot: string): Promise<NornRunLaunchRequest> {
-	return parseRunLaunchRequest(JSON.parse(await readFile(join(runRoot, LAUNCH_REQUEST_FILE_NAME), "utf8")));
+export async function readRunLaunchRequest(
+	runRoot: string,
+): Promise<NornRunLaunchRequest> {
+	return parseRunLaunchRequest(
+		JSON.parse(await readFile(join(runRoot, LAUNCH_REQUEST_FILE_NAME), "utf8")),
+	);
 }
 
-export async function writeRunResumeRequest(runRoot: string, request: NornRunResumeRequest): Promise<void> {
+export async function writeRunResumeRequest(
+	runRoot: string,
+	request: NornRunResumeRequest,
+): Promise<void> {
 	const path = join(runRoot, RESUME_REQUEST_FILE_NAME);
 	const stagedPath = `${path}.${randomUUID()}.tmp`;
 	try {
@@ -48,11 +58,17 @@ export async function writeRunResumeRequest(runRoot: string, request: NornRunRes
 	}
 }
 
-export async function readRunResumeRequest(runRoot: string): Promise<NornRunResumeRequest> {
-	return parseRunResumeRequest(JSON.parse(await readFile(join(runRoot, RESUME_REQUEST_FILE_NAME), "utf8")));
+export async function readRunResumeRequest(
+	runRoot: string,
+): Promise<NornRunResumeRequest> {
+	return parseRunResumeRequest(
+		JSON.parse(await readFile(join(runRoot, RESUME_REQUEST_FILE_NAME), "utf8")),
+	);
 }
 
-export async function readOptionalRunResumeRequest(runRoot: string): Promise<NornRunResumeRequest | undefined> {
+export async function readOptionalRunResumeRequest(
+	runRoot: string,
+): Promise<NornRunResumeRequest | undefined> {
 	try {
 		return await readRunResumeRequest(runRoot);
 	} catch (error) {
@@ -61,34 +77,70 @@ export async function readOptionalRunResumeRequest(runRoot: string): Promise<Nor
 	}
 }
 
-export function matchesRunResumeRequest(actual: NornRunResumeRequest | undefined, expected: NornRunResumeRequest): boolean {
-	return actual?.id === expected.id && (actual.requestId ?? actual.createdAt) === (expected.requestId ?? expected.createdAt);
+export function matchesRunResumeRequest(
+	actual: NornRunResumeRequest | undefined,
+	expected: NornRunResumeRequest,
+): boolean {
+	return (
+		actual?.id === expected.id &&
+		(actual.requestId ?? actual.createdAt) ===
+			(expected.requestId ?? expected.createdAt)
+	);
 }
 
-export async function clearRunResumeRequest(input: { readonly runRoot: string; readonly request: NornRunResumeRequest; readonly lease: NornRunLease }): Promise<void> {
+export async function clearRunResumeRequest(input: {
+	readonly runRoot: string;
+	readonly request: NornRunResumeRequest;
+	readonly lease: NornRunLease;
+}): Promise<void> {
 	await input.lease.assertOwned();
-	if (matchesRunResumeRequest(await readOptionalRunResumeRequest(input.runRoot), input.request)) {
+	if (
+		matchesRunResumeRequest(
+			await readOptionalRunResumeRequest(input.runRoot),
+			input.request,
+		)
+	) {
 		await rm(join(input.runRoot, RESUME_REQUEST_FILE_NAME), { force: true });
 	}
 }
 
 function parseRunLaunchRequest(value: unknown): NornRunLaunchRequest {
-	if (!value || typeof value !== "object") throw new Error("Invalid workflow launch request");
+	if (!value || typeof value !== "object")
+		throw new Error("Invalid workflow launch request");
 	const request = value as Partial<NornRunLaunchRequest>;
-	if (request.version !== 2 || request.type !== "run") throw new Error("Unsupported workflow launch request");
-	if (typeof request.id !== "string" || request.id.length === 0) throw new Error("Invalid workflow launch request id");
-	if (typeof request.name !== "string" || request.name.length === 0) throw new Error("Invalid workflow launch request name");
-	if (typeof request.workflowId !== "string" || request.workflowId.length === 0) throw new Error("Invalid workflow launch request workflow id");
-	if (typeof request.createdAt !== "string" || Number.isNaN(Date.parse(request.createdAt))) throw new Error("Invalid workflow launch request timestamp");
+	if (request.version !== 2 || request.type !== "run")
+		throw new Error("Unsupported workflow launch request");
+	if (typeof request.id !== "string" || request.id.length === 0)
+		throw new Error("Invalid workflow launch request id");
+	if (typeof request.name !== "string" || request.name.length === 0)
+		throw new Error("Invalid workflow launch request name");
+	if (typeof request.workflowId !== "string" || request.workflowId.length === 0)
+		throw new Error("Invalid workflow launch request workflow id");
+	if (
+		typeof request.createdAt !== "string" ||
+		Number.isNaN(Date.parse(request.createdAt))
+	)
+		throw new Error("Invalid workflow launch request timestamp");
 	return request as NornRunLaunchRequest;
 }
 
 function parseRunResumeRequest(value: unknown): NornRunResumeRequest {
-	if (!value || typeof value !== "object") throw new Error("Invalid workflow resume request");
+	if (!value || typeof value !== "object")
+		throw new Error("Invalid workflow resume request");
 	const request = value as Partial<NornRunResumeRequest>;
-	if (request.version !== 2 || request.type !== "resume") throw new Error("Unsupported workflow resume request");
-	if (typeof request.id !== "string" || request.id.length === 0) throw new Error("Invalid workflow resume request id");
-	if (request.requestId !== undefined && (typeof request.requestId !== "string" || request.requestId.length === 0)) throw new Error("Invalid workflow resume request token");
-	if (typeof request.createdAt !== "string" || Number.isNaN(Date.parse(request.createdAt))) throw new Error("Invalid workflow resume request timestamp");
+	if (request.version !== 2 || request.type !== "resume")
+		throw new Error("Unsupported workflow resume request");
+	if (typeof request.id !== "string" || request.id.length === 0)
+		throw new Error("Invalid workflow resume request id");
+	if (
+		request.requestId !== undefined &&
+		(typeof request.requestId !== "string" || request.requestId.length === 0)
+	)
+		throw new Error("Invalid workflow resume request token");
+	if (
+		typeof request.createdAt !== "string" ||
+		Number.isNaN(Date.parse(request.createdAt))
+	)
+		throw new Error("Invalid workflow resume request timestamp");
 	return request as NornRunResumeRequest;
 }

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

@@ -10,7 +10,10 @@ export type NornLogWriteStream = {
 };
 
 export class NornRunLogs {
-	constructor(private readonly logsRoot: string, private readonly files: NornFileCoordinator) {}
+	constructor(
+		private readonly logsRoot: string,
+		private readonly files: NornFileCoordinator,
+	) {}
 
 	async write(path: string, content: string): Promise<void> {
 		await this.files.writeText(this.resolveLogPath(path), content);
@@ -33,7 +36,12 @@ export class NornRunLogs {
 		if (isAbsolute(path)) throw new Error(`Log path must be relative: ${path}`);
 		const resolvedPath = resolve(this.logsRoot, path);
 		const relativePath = relative(this.logsRoot, resolvedPath);
-		if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+		if (
+			relativePath === "" ||
+			relativePath === ".." ||
+			relativePath.startsWith(`..${sep}`) ||
+			isAbsolute(relativePath)
+		) {
 			throw new Error(`Log path escapes logs directory: ${path}`);
 		}
 		return resolvedPath;