@tryaura/aura-testkit 0.1.1 → 0.2.0

package/README.md

@@ -13,14 +13,20 @@ run spawns.
 ```ts
 import { createSeedBuilder, runCheck } from "@tryaura/aura-testkit";
 
-it("reports a legacy config", async () => {
+it("runs a distribution against a fake machine", async () => {
   await using seed = await createSeedBuilder()
     .homeFile(".fixture/config.txt", "legacy=true\n")
     .workspaceFile("AGENTS.md", "workspace instructions\n")
     .shim("fixture-agent", [{ args: ["--version"], stdout: "fixture-agent 1.2.3\n" }])
     .build();
 
-  const result = await runCheck({ distro, seed });
+  const result = await runCheck({
+    distro: {
+      branding: { command: "fixture", displayName: "Fixture Doctor" },
+      plugins: [],
+    },
+    seed,
+  });
 
   expect(result.findings).toMatchInlineSnapshot();
 });
@@ -59,6 +65,26 @@ Every invocation is recorded, matched or not:
 await expect(seed.invocations("fixture-agent")).resolves.toEqual([["--version"]]);
 ```
 
+Asking for a command that was not seeded rejects and lists the known shims. A seeded command that
+has not run resolves to an empty list.
+
+### Shim record contract
+
+The invocation log is a public, versioned format. Each invocation is one ASCII line:
+
+```text
+aura-testkit-v1<TAB><argument-count><TAB><base64-UTF-8-argument>...<LF>
+```
+
+Empty and multiline arguments round-trip because every argument is encoded separately. A shim
+builds the complete record in memory and appends it with one `printf`, so parallel invocations do
+not interleave fields. Records are capped at 2,048 bytes; an invocation over that limit writes a
+versioned truncation marker, and `seed.invocations(command)` rejects with the record size and limit
+instead of returning incomplete arguments.
+
+Generated shims require a POSIX shell and the standard `base64` and `tr` utilities available at
+`/usr/bin`. Seed building fails immediately on Windows with an explicit platform error.
+
 Versioned official-app fixtures are also exported for adapter and binary integration tests:
 
 ```ts
@@ -88,7 +114,8 @@ await using cursorSeed = await createCursorSeed({
   needs to prove a check ran: a check that threw reports no findings and is explained only by
   `report.diagnostics`.
 - `findings` — shorthand for `report.findings`.
-- `exitCode` — `0`, `1`, or `2`.
+- `exitCode` — `0` for a completed check, `2` for usage/state conflicts, or `3` for operational
+  failures. Inspect report status or severity counts to assert finding health.
 - `diffs` — every change under the fake HOME and workspace, as unified patches whose first line is
   the entry's permission bits. Permission-only changes, empty directories, and binary files are all
   visible. The seeded `PATH` directory is not diffed; use `seed.invocations` for what a shim did.

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { CheckReport, CheckReport as CheckReport$1, CliDistro, CliExitCode, ReportFinding } from "@tryaura/aura-cli";
+import { CheckReport, CheckReport as CheckReport$1, CliDistro, CliDistro as CliDistro$1, CliExitCode, ReportFinding } from "@tryaura/aura-cli";
 import { Environment } from "@tryaura/aura-sdk";
 //#region src/types.d.ts
 /**
@@ -36,8 +36,8 @@ interface TestSeed {
    * Every invocation of one seeded shim, in the order it happened.
    *
    * Records invocations no response matched too, which is what turns "the shim answered `exit 2`"
-   * into "the adapter asked for arguments no response declares". Empty for a command that was never
-   * run, or was never seeded.
+   * into "the adapter asked for arguments no response declares". Empty when the seeded command was
+   * never run. Asking for a command that was not seeded throws and names the known shims.
    */
   readonly invocations: (command: string) => Promise<readonly (readonly string[])[]>;
 }
@@ -59,13 +59,20 @@ type SeedContent = string | ((roots: SeedRoots) => string);
 interface TestSeedBuilder {
   homeFile(path: string, content: SeedContent): TestSeedBuilder;
   shim(command: string, responses: readonly ShimResponse[]): TestSeedBuilder;
+  /**
+   * Records the seeded workspace preset as trusted in the seed's `agents/aura.json`.
+   *
+   * A repository preset applies only after a person accepted it, and `--yes` runs never accept
+   * one; a seed that wants the preset in effect declares the acceptance that already happened.
+   */
+  trustWorkspacePreset(path?: string): TestSeedBuilder;
   workspaceFile(path: string, content: SeedContent): TestSeedBuilder;
   build(): Promise<TestSeed>;
 }
 interface RunCheckOptions {
   /** Check-command flags other than `--json`, which the runner always supplies. */
   readonly args?: readonly string[] | undefined;
-  readonly distro: CliDistro;
+  readonly distro: CliDistro$1;
   readonly seed: TestSeed;
 }
 /** Options for running a compiled Aura distribution against a deterministic seed. */
@@ -131,7 +138,7 @@ declare function runCheck(options: RunCheckOptions): Promise<TestRunResult>;
 interface RunSetupOptions {
   /** Setup-command flags other than `--yes`, which the runner always supplies. */
   readonly args?: readonly string[] | undefined;
-  readonly distro: CliDistro;
+  readonly distro: CliDistro$1;
   /** Extra variables visible to the run, such as a skill-directory token. `PATH` stays seeded. */
   readonly environmentVariables?: Readonly<Record<string, string>> | undefined;
   readonly seed: TestSeed;
@@ -196,7 +203,7 @@ type TreeEntry = BinaryEntry | DirectoryEntry | FileEntry | SymlinkEntry;
 type FilesystemSnapshot = ReadonlyMap<string, TreeEntry>;
 declare function captureFilesystem(seed: TestSeed): Promise<FilesystemSnapshot>;
 //#endregion
-//#region src/seed.d.ts
+//#region src/seed.boundary.d.ts
 /** Starts a fluent description of one isolated fake machine. */
 declare function createSeedBuilder(): TestSeedBuilder;
 //#endregion
@@ -303,4 +310,4 @@ declare function cursorShimResponses(options: Pick<CursorSeedOptions, "version">
 /** Builds documented Cursor rule and MCP configuration against an exact editor version. */
 declare function createCursorSeed(options: CursorSeedOptions): Promise<TestSeed>;
 //#endregion
-export { ANY_ARGUMENT, CODEX_NESTED_PACKAGE, type CheckReport, type ClaudeCodeFixtureVersion, type ClaudeCodeSeedOptions, type CodexFixtureVersion, type CodexProjectInstructions, type CodexSeedOptions, type ConvergedTwiceResult, type ConvergenceRunResult, type CursorFixtureVersion, type CursorRulesFixture, type CursorSeedOptions, type FilesystemSnapshot, type MockDirectory, type MockDirectoryBuilder, type MockDirectoryFile, type MockDirectoryListing, type MockDirectoryRequest, type RunBinaryCheckOptions, type RunCheckOptions, type RunSetupOptions, type SetupRunResult, type ShimArgument, type ShimResponse, type TestFileDiff, type TestFileDiffStatus, type TestRunResult, type TestSeed, type TestSeedBuilder, captureFilesystem, claudeCodeShimResponses, codexShimResponses, createClaudeCodeSeed, createCodexSeed, createCursorSeed, createMockDirectoryBuilder, createSeedBuilder, cursorShimResponses, expectConvergedTwice, loopbackOnlyHttpGet, runBinaryCheck, runCheck, runSetup };
+export { ANY_ARGUMENT, CODEX_NESTED_PACKAGE, type CheckReport, type ClaudeCodeFixtureVersion, type ClaudeCodeSeedOptions, type CliDistro, type CodexFixtureVersion, type CodexProjectInstructions, type CodexSeedOptions, type ConvergedTwiceResult, type ConvergenceRunResult, type CursorFixtureVersion, type CursorRulesFixture, type CursorSeedOptions, type FilesystemSnapshot, type MockDirectory, type MockDirectoryBuilder, type MockDirectoryFile, type MockDirectoryListing, type MockDirectoryRequest, type RunBinaryCheckOptions, type RunCheckOptions, type RunSetupOptions, type SetupRunResult, type ShimArgument, type ShimResponse, type TestFileDiff, type TestFileDiffStatus, type TestRunResult, type TestSeed, type TestSeedBuilder, captureFilesystem, claudeCodeShimResponses, codexShimResponses, createClaudeCodeSeed, createCodexSeed, createCursorSeed, createMockDirectoryBuilder, createSeedBuilder, cursorShimResponses, expectConvergedTwice, loopbackOnlyHttpGet, runBinaryCheck, runCheck, runSetup };

package/dist/index.js

@@ -4,7 +4,7 @@ import { createHash } from "node:crypto";
 import { chmod, lstat, mkdir, mkdtemp, readFile, readdir, readlink, realpath, rm, writeFile } from "node:fs/promises";
 import { PassThrough, Readable } from "node:stream";
 import { runCli } from "@tryaura/aura-cli";
-import { tmpdir } from "node:os";
+import { platform, tmpdir } from "node:os";
 import { DEFAULT_HTTP_TIMEOUT_MS, MAX_HTTP_RESPONSE_BYTES, MAX_HTTP_TIMEOUT_MS } from "@tryaura/aura-sdk";
 import { createServer } from "node:http";
 //#region ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/base.js
@@ -850,12 +850,12 @@ function toPortablePath(path) {
 //#endregion
 //#region src/guards.ts
 /** Narrows to a plain JSON-shaped object, excluding arrays and null. */
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /** Freezes a JSON-shaped value all the way down. */
 function deepFreeze(value) {
-	if (!isRecord(value) && !Array.isArray(value)) return value;
+	if (!isRecord$1(value) && !Array.isArray(value)) return value;
 	for (const property of Object.values(value)) deepFreeze(property);
 	return Object.freeze(value);
 }
@@ -886,7 +886,7 @@ function reject(path, expectation, problems) {
 /** Validates the declared keys and ignores every other one, which is what lets the report grow. */
 function shape(fields) {
 	return (value, path, problems) => {
-		if (!isRecord(value)) return reject(path, "an object", problems);
+		if (!isRecord$1(value)) return reject(path, "an object", problems);
 		let valid = true;
 		for (const [key, check] of Object.entries(fields)) valid = check(value[key], `${path}.${key}`, problems) && valid;
 		return valid;
@@ -902,7 +902,7 @@ function arrayOf(check) {
 }
 function recordOf(check) {
 	return (value, path, problems) => {
-		if (!isRecord(value)) return reject(path, "an object", problems);
+		if (!isRecord$1(value)) return reject(path, "an object", problems);
 		let valid = true;
 		for (const [key, entry] of Object.entries(value)) valid = check(entry, `${path}.${key}`, problems) && valid;
 		return valid;
@@ -959,15 +959,15 @@ const findingFields = shape({
 */
 const finding = (value, path, problems) => {
 	const valid = findingFields(value, path, problems);
-	return isRecord(value) ? tableRowsAreReadable(value, path, problems) && valid : valid;
+	return isRecord$1(value) ? tableRowsAreReadable(value, path, problems) && valid : valid;
 };
 function tableRowsAreReadable(value, path, problems) {
 	const presentation = value["presentation"];
-	if (!isRecord(presentation) || presentation["kind"] !== "metadata-table") return true;
+	if (!isRecord$1(presentation) || presentation["kind"] !== "metadata-table") return true;
 	const rowsKey = presentation["rowsKey"];
 	const metadata = value["metadata"];
-	const rows = typeof rowsKey === "string" && isRecord(metadata) ? metadata[rowsKey] : void 0;
-	if (!Array.isArray(rows) || !rows.every(isRecord)) return reject(`${path}.metadata.${typeof rowsKey === "string" ? rowsKey : "?"}`, "an array of objects, because presentation.rowsKey names it", problems);
+	const rows = typeof rowsKey === "string" && isRecord$1(metadata) ? metadata[rowsKey] : void 0;
+	if (!Array.isArray(rows) || !rows.every(isRecord$1)) return reject(`${path}.metadata.${typeof rowsKey === "string" ? rowsKey : "?"}`, "an array of objects, because presentation.rowsKey names it", problems);
 	const keys = columnKeys(presentation["columns"]);
 	if (keys.length === 0) return true;
 	return rows.every((row, index) => keys.some((key) => row[key] !== void 0) ? true : reject(`${path}.metadata.${String(rowsKey)}[${String(index)}]`, `a row carrying at least one column key (${keys.join(", ")})`, problems));
@@ -975,7 +975,7 @@ function tableRowsAreReadable(value, path, problems) {
 function columnKeys(columns) {
 	if (!Array.isArray(columns)) return [];
 	return columns.flatMap((column) => {
-		const key = isRecord(column) ? column["key"] : void 0;
+		const key = isRecord$1(column) ? column["key"] : void 0;
 		return typeof key === "string" ? [key] : [];
 	});
 }
@@ -1039,7 +1039,7 @@ const REPORT = {
 	})
 };
 function isJsonObject(value) {
-	return isRecord(value) && Object.values(value).every(isJsonValue);
+	return isRecord$1(value) && Object.values(value).every(isJsonValue);
 }
 function isJsonValue(value) {
 	return value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string" || Array.isArray(value) && value.every(isJsonValue) || isJsonObject(value);
@@ -1218,7 +1218,7 @@ function executeBinary(options) {
 	});
 }
 //#endregion
-//#region ../core/src/http.ts
+//#region ../core/src/http.boundary.ts
 /**
 * Hosts allowed to serve plain `http:`.
 *
@@ -1345,6 +1345,39 @@ function failureReason(error) {
 	return name === "TimeoutError" || name === "AbortError" ? "timeout" : "network";
 }
 //#endregion
+//#region ../core/src/managed-block/protocol.ts
+/**
+* Normalizes snippet text to the bytes covered by the managed-block hash protocol.
+*
+* Trailing newlines are trimmed by scanning rather than with `/\n+$/`, whose backtracking is
+* quadratic when a long newline run does not reach the end of the string.
+*/
+function canonicalizeManagedSnippet(content) {
+	const normalized = content.replace(/\r\n?/g, "\n");
+	let end = normalized.length;
+	while (end > 0 && normalized[end - 1] === "\n") end -= 1;
+	return `${normalized.slice(0, end)}\n`;
+}
+/** Computes the protocol hash for text already in {@link canonicalizeManagedSnippet} form. */
+function hashCanonicalManagedSnippet(canonical) {
+	return createHash("sha256").update(canonical, "utf8").digest("hex");
+}
+/** Computes the protocol hash for a snippet's canonical UTF-8 contents. */
+function hashManagedSnippet(content) {
+	return hashCanonicalManagedSnippet(canonicalizeManagedSnippet(content));
+}
+//#endregion
+//#region ../core/src/preset/repo-trust.ts
+/**
+* Hashes repository preset contents for the trust record.
+*
+* Uses the managed-snippet canonicalization so a checkout that rewrites line endings does not
+* invalidate a trust the user already granted to the same bytes-as-authored.
+*/
+function hashRepoPreset(content) {
+	return hashManagedSnippet(content);
+}
+//#endregion
 //#region src/http.ts
 const LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "[::1]"]);
 const realHttpGet = createHttpGet();
@@ -1540,6 +1573,8 @@ const ANY_ARGUMENT = Symbol("aura-testkit.anyArgument");
 //#region src/shims.ts
 const COMMAND_NAME = /^[A-Za-z0-9._+-]+$/u;
 const RESERVED_NAMES = /* @__PURE__ */ new Set([".", ".."]);
+const RECORD_FORMAT = "aura-testkit-v1";
+const RECORD_LIMIT_BYTES = 2048;
 async function writeShim(options) {
 	const { command, logDir, pathDir, responses } = options;
 	validateShim(command, responses);
@@ -1550,12 +1585,15 @@ async function writeShim(options) {
 /**
 * Reads back every invocation one shim recorded.
 *
-* The log frames each record as its argument count followed by that many arguments, all
-* NUL-terminated. Arguments cannot contain NUL — {@link validateShim} rejects that — so the framing
-* stays unambiguous for empty arguments and for arguments holding newlines.
+* Each invocation is one LF-terminated ASCII record containing the format version, argument count,
+* and one base64-encoded UTF-8 field per argument, separated by tabs. The shim appends the complete
+* record with one `printf`, so concurrent invocations cannot interleave individual fields.
+*
+* A missing log means the seeded shim has not run. Invalid command names and malformed or truncated
+* records throw instead of being conflated with that valid empty state.
 */
 async function readInvocations(logDir, command) {
-	if (!isPortableCommandName(command)) return [];
+	if (!isPortableCommandName(command)) throw new Error(`Shim command must be a portable executable name. Received: ${command}`);
 	let log;
 	try {
 		log = await readFile(join(logDir, command), "utf8");
@@ -1563,16 +1601,10 @@ async function readInvocations(logDir, command) {
 		if (isNotFound(error)) return [];
 		throw error;
 	}
-	const fields = log.split("\0");
-	fields.pop();
 	const invocations = [];
-	let cursor = 0;
-	while (cursor < fields.length) {
-		const count = Number(fields[cursor]);
-		if (!Number.isInteger(count) || count < 0 || cursor + 1 + count > fields.length) throw new Error(`Shim ${command} wrote an invocation log this runner cannot read.`);
-		invocations.push(Object.freeze(fields.slice(cursor + 1, cursor + 1 + count)));
-		cursor += 1 + count;
-	}
+	const records = log.split("\n");
+	if (records.pop() !== "") throw unreadableInvocationLog(command);
+	for (const record of records) invocations.push(parseInvocationRecord(command, record));
 	return Object.freeze(invocations);
 }
 function validateShim(command, responses) {
@@ -1610,12 +1642,17 @@ function validateResponse(command, response) {
 function renderShim(command, logPath, responses) {
 	return [
 		"#!/bin/sh",
-		"{",
-		`  printf '%s\\0' "$#"`,
-		"  for aura_recorded in \"$@\"; do",
-		`    printf '%s\\0' "$aura_recorded"`,
-		"  done",
-		`} >> ${shellQuote(logPath)}`,
+		`aura_record="${RECORD_FORMAT}\t$#"`,
+		"for aura_recorded in \"$@\"; do",
+		`  aura_encoded=$(printf '%s' "$aura_recorded" | /usr/bin/base64 | /usr/bin/tr -d '\\r\\n')`,
+		"  aura_record=\"${aura_record}	${aura_encoded}\"",
+		"done",
+		"aura_record=\"${aura_record}\n\"",
+		"aura_record_length=${#aura_record}",
+		`if [ "$aura_record_length" -gt ${String(RECORD_LIMIT_BYTES)} ]; then`,
+		`  aura_record="${RECORD_FORMAT}\ttruncated\t\${aura_record_length}\n"`,
+		"fi",
+		`printf '%s' "$aura_record" >> ${shellQuote(logPath)}`,
 		...responses.map(renderResponse),
 		`printf '%s' ${shellQuote(`aura-testkit: unmatched invocation: ${command}`)} >&2`,
 		"for aura_reported in \"$@\"; do",
@@ -1639,13 +1676,47 @@ function shellQuote(value) {
 	return `'${value.replaceAll("'", `'"'"'`)}'`;
 }
 function isNotFound(error) {
-	return isRecord(error) && error["code"] === "ENOENT";
+	return isRecord$1(error) && error["code"] === "ENOENT";
+}
+function isUnsignedInteger(value) {
+	return /^(?:0|[1-9][0-9]*)$/u.test(value);
+}
+function parseInvocationRecord(command, record) {
+	const fields = record.split("	");
+	if (fields[0] !== RECORD_FORMAT) throw unreadableInvocationLog(command);
+	if (fields[1] === "truncated") throwTruncatedInvocation(command, fields);
+	return parseInvocationFields(command, fields);
+}
+function throwTruncatedInvocation(command, fields) {
+	const recordLength = fields[2];
+	if (fields.length !== 3 || recordLength === void 0 || !isUnsignedInteger(recordLength)) throw unreadableInvocationLog(command);
+	throw new Error(`Shim ${command} invocation produced a ${recordLength}-byte log record, exceeding the ${String(RECORD_LIMIT_BYTES)}-byte atomic limit. Reduce the invocation's arguments.`);
+}
+function parseInvocationFields(command, fields) {
+	const countField = fields[1];
+	if (countField === void 0 || !isUnsignedInteger(countField)) throw unreadableInvocationLog(command);
+	const count = Number(countField);
+	if (!Number.isSafeInteger(count) || fields.length !== count + 2) throw unreadableInvocationLog(command);
+	return Object.freeze(fields.slice(2).map((field) => decodeArgument(command, field)));
+}
+function decodeArgument(command, value) {
+	const bytes = Buffer.from(value, "base64");
+	if (bytes.toString("base64") !== value) throw unreadableInvocationLog(command);
+	try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	} catch {
+		throw unreadableInvocationLog(command);
+	}
+}
+function unreadableInvocationLog(command) {
+	return /* @__PURE__ */ new Error(`Shim ${command} wrote an invocation log this runner cannot read.`);
 }
 //#endregion
-//#region src/seed.ts
+//#region src/seed.boundary.ts
 var SeedBuilder = class {
 	#homeFiles = /* @__PURE__ */ new Map();
 	#shims = /* @__PURE__ */ new Map();
+	#trustedPresets = /* @__PURE__ */ new Set();
 	#workspaceFiles = /* @__PURE__ */ new Map();
 	homeFile(path, content) {
 		addFile(this.#homeFiles, "HOME", path, content);
@@ -1663,11 +1734,16 @@ var SeedBuilder = class {
 		});
 		return this;
 	}
+	trustWorkspacePreset(path = ".aura/preset.json") {
+		this.#trustedPresets.add(normalizeSeedPath(path));
+		return this;
+	}
 	workspaceFile(path, content) {
 		addFile(this.#workspaceFiles, "workspace", path, content);
 		return this;
 	}
 	async build() {
+		assertSupportedPlatform(platform());
 		const root = await realpath(await mkdtemp(join(tmpdir(), "aura-testkit-")));
 		const homeDir = join(root, "home");
 		const logDir = join(root, "invocations");
@@ -1692,6 +1768,7 @@ var SeedBuilder = class {
 				pathDir,
 				responses: shim.responses
 			})));
+			if (this.#trustedPresets.size > 0) await recordTrustedPresets(homeDir, workspaceDir, this.#trustedPresets);
 		} catch (error) {
 			await rm(root, {
 				force: true,
@@ -1710,7 +1787,13 @@ var SeedBuilder = class {
 		return Object.freeze({
 			cleanup,
 			homeDir,
-			invocations: (command) => commands.has(command) ? readInvocations(logDir, command) : Promise.resolve([]),
+			invocations: async (command) => {
+				if (!commands.has(command)) {
+					const known = [...commands].sort().join(", ") || "(none)";
+					throw new Error(`Unknown shim command: ${command}. Known shims: ${known}.`);
+				}
+				return readInvocations(logDir, command);
+			},
 			pathDir,
 			workspaceDir,
 			[Symbol.asyncDispose]: cleanup
@@ -1721,6 +1804,69 @@ var SeedBuilder = class {
 function createSeedBuilder() {
 	return new SeedBuilder();
 }
+/**
+* Merges trust records for the seeded presets into the seed's manifest.
+*
+* A trust record binds an absolute preset path to a hash of its contents, and both exist only
+* once the seed is materialized, so this runs after the files are written and reads them back.
+*/
+async function recordTrustedPresets(homeDir, workspaceDir, presets) {
+	const manifestPath = join(homeDir, "agents", "aura.json");
+	const existing = await readFile(manifestPath, "utf8").catch(() => void 0);
+	const manifest = existing === void 0 ? {
+		apps: {},
+		mcpServers: [],
+		ownership: {},
+		schemaVersion: 1,
+		skills: [],
+		snippets: []
+	} : parseSeedManifest(existing, manifestPath);
+	const added = [];
+	for (const relativePath of presets) {
+		const path = join(workspaceDir, relativePath);
+		const content = await readFile(path, "utf8").catch(() => {
+			throw new Error(`trustWorkspacePreset needs the seeded workspace file: ${relativePath}`);
+		});
+		added.push({
+			hash: hashRepoPreset(content),
+			path
+		});
+	}
+	const addedPaths = new Set(added.map((entry) => entry.path));
+	const trustedRepoPresets = [...parseTrustedRepoPresets(manifest["trustedRepoPresets"], manifestPath).filter((entry) => !addedPaths.has(entry.path)), ...added];
+	if (trustedRepoPresets.length > 64) throw new Error(`Seed manifest ${manifestPath} exceeds the ${String(64)} trusted repository preset limit`);
+	await mkdir(dirname(manifestPath), { recursive: true });
+	await writeFile(manifestPath, `${JSON.stringify({
+		...manifest,
+		trustedRepoPresets
+	}, void 0, 2)}\n`, {
+		encoding: "utf8",
+		mode: 384
+	});
+}
+function parseSeedManifest(source, path) {
+	const value = JSON.parse(source);
+	if (!isRecord(value)) throw new Error(`Seed manifest ${path} must contain a JSON object`);
+	return value;
+}
+function parseTrustedRepoPresets(value, manifestPath) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new Error(`Seed manifest ${manifestPath} trustedRepoPresets must be an array`);
+	return value.map((candidate, index) => {
+		if (!isRecord(candidate) || typeof candidate["hash"] !== "string" || typeof candidate["path"] !== "string") throw new Error(`Seed manifest ${manifestPath} trustedRepoPresets[${String(index)}] must contain string hash and path fields`);
+		return {
+			...candidate,
+			hash: candidate["hash"],
+			path: candidate["path"]
+		};
+	});
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertSupportedPlatform(platform) {
+	if (platform === "win32") throw new Error("Aura testkit requires a POSIX shell and cannot build seeds on Windows.");
+}
 function addFile(files, scope, path, content) {
 	const normalized = normalizeSeedPath(path);
 	if (files.has(normalized)) throw new Error(`${scope} file is already seeded: ${normalized}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryaura/aura-testkit",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Deterministic filesystem seeds and CLI harnesses for Aura plugins and distributions.",
   "keywords": [
     "aura",
@@ -30,17 +30,17 @@
     "access": "public"
   },
   "dependencies": {
-    "@tryaura/aura-sdk": "0.1.1",
-    "@tryaura/aura-cli": "0.1.1"
+    "@tryaura/aura-cli": "0.2.0",
+    "@tryaura/aura-sdk": "0.2.0"
   },
   "devDependencies": {
     "@types/node": "24.13.3",
     "diff": "9.0.0",
     "vitest": "4.1.10",
-    "@tryaura/core": "0.0.0",
     "@tryaura/adapter-codex": "0.0.0",
+    "@tryaura/adapter-claude-code": "0.0.0",
     "@tryaura/adapter-cursor": "0.0.0",
-    "@tryaura/adapter-claude-code": "0.0.0"
+    "@tryaura/core": "0.0.0"
   },
   "engines": {
     "node": ">=24"