@pi-in-go/pigpen-ahp 0.1.0

package/proof/oracle/test/delete-session.test.ts

@@ -0,0 +1,142 @@
+import assert from "node:assert/strict";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { delimiter, join } from "node:path";
+import { describe, it } from "node:test";
+import { deleteSessionFile } from "../src/pi/delete-session.ts";
+
+function withPath(path: string, run: () => void): void {
+	const previous = process.env.PATH;
+	process.env.PATH = path;
+	try {
+		run();
+	} finally {
+		if (previous === undefined) delete process.env.PATH;
+		else process.env.PATH = previous;
+	}
+}
+
+function fakeTrash(
+	root: string,
+	behavior: "remove" | "fail" | "remove-and-fail" | "leave",
+): {
+	bin: string;
+	calls: string;
+} {
+	const bin = join(root, "bin");
+	const calls = join(root, "trash-calls.json");
+	mkdirSync(bin);
+	const executable = join(bin, "trash");
+	writeFileSync(
+		executable,
+		[
+			`#!${process.execPath}`,
+			'const fs = require("node:fs");',
+			"const args = process.argv.slice(2);",
+			`fs.writeFileSync(${JSON.stringify(calls)}, JSON.stringify(args));`,
+			"const target = args.at(-1);",
+			...(["remove", "remove-and-fail"].includes(behavior) ? ["fs.rmSync(target, { force: true });"] : []),
+			...(behavior === "fail" ? ["process.exit(1);"] : []),
+			...(behavior === "remove-and-fail" ? ["process.exit(1);"] : []),
+		].join("\n"),
+	);
+	chmodSync(executable, 0o755);
+	return { bin, calls };
+}
+
+describe("session file deletion", () => {
+	it("treats an already-missing file as success", () => {
+		const root = mkdtempSync(join(tmpdir(), "pi-ahp-delete-missing-"));
+		try {
+			assert.deepEqual(deleteSessionFile(join(root, "session.jsonl")), {
+				ok: true,
+				method: "missing",
+			});
+		} finally {
+			rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("prefers trash and guards a path that looks like an option", () => {
+		const root = mkdtempSync(join(tmpdir(), "pi-ahp-delete-trash-"));
+		const previousCwd = process.cwd();
+		try {
+			const fake = fakeTrash(root, "remove");
+			process.chdir(root);
+			writeFileSync("-session.jsonl", "session\n");
+			withPath(`${fake.bin}${delimiter}${process.env.PATH ?? ""}`, () => {
+				assert.deepEqual(deleteSessionFile("-session.jsonl"), { ok: true, method: "trash" });
+			});
+			assert.equal(existsSync("-session.jsonl"), false);
+			assert.deepEqual(JSON.parse(readFileSync(fake.calls, "utf8")), ["--", "-session.jsonl"]);
+		} finally {
+			process.chdir(previousCwd);
+			rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("falls back to unlink when trash exits successfully but leaves the file", () => {
+		const root = mkdtempSync(join(tmpdir(), "pi-ahp-delete-left-behind-"));
+		try {
+			const fake = fakeTrash(root, "leave");
+			const target = join(root, "session.jsonl");
+			writeFileSync(target, "session\n");
+			withPath(`${fake.bin}${delimiter}${process.env.PATH ?? ""}`, () => {
+				assert.deepEqual(deleteSessionFile(target), { ok: true, method: "unlink" });
+			});
+			assert.equal(existsSync(target), false);
+		} finally {
+			rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("recognizes trash success even when the command exits nonzero", () => {
+		const root = mkdtempSync(join(tmpdir(), "pi-ahp-delete-moved-"));
+		try {
+			const fake = fakeTrash(root, "remove-and-fail");
+			const target = join(root, "session.jsonl");
+			writeFileSync(target, "session\n");
+			withPath(`${fake.bin}${delimiter}${process.env.PATH ?? ""}`, () => {
+				assert.deepEqual(deleteSessionFile(target), { ok: true, method: "trash" });
+			});
+			assert.equal(existsSync(target), false);
+		} finally {
+			rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("falls back to unlink when trash is unavailable or fails", () => {
+		for (const behavior of ["missing", "fail"] as const) {
+			const root = mkdtempSync(join(tmpdir(), `pi-ahp-delete-${behavior}-`));
+			try {
+				const bin = behavior === "fail" ? fakeTrash(root, "fail").bin : join(root, "empty-bin");
+				if (behavior === "missing") mkdirSync(bin);
+				const target = join(root, "session.jsonl");
+				writeFileSync(target, "session\n");
+				withPath(bin, () => {
+					assert.deepEqual(deleteSessionFile(target), { ok: true, method: "unlink" });
+				});
+				assert.equal(existsSync(target), false);
+			} finally {
+				rmSync(root, { recursive: true, force: true });
+			}
+		}
+	});
+
+	it("returns an unlink error instead of claiming deletion", () => {
+		const root = mkdtempSync(join(tmpdir(), "pi-ahp-delete-error-"));
+		const target = join(root, "directory.jsonl");
+		mkdirSync(target);
+		try {
+			withPath(root, () => {
+				const result = deleteSessionFile(target);
+				assert.equal(result.ok, false);
+				assert.equal(result.method, "unlink");
+				assert.match(result.error ?? "", /directory|operation not permitted|permission denied/is);
+				assert.equal(existsSync(target), true);
+			});
+		} finally {
+			rmSync(root, { recursive: true, force: true });
+		}
+	});
+});

package/proof/oracle/test/direct-settings.test.ts

@@ -0,0 +1,81 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { describe, it } from "node:test";
+import { loadDirectListenerSettings, SettingsError } from "../src/host/direct-settings.ts";
+
+function fixture(): { path: string; write(value: unknown): void; close(): void } {
+	const root = mkdtempSync(join(tmpdir(), "pi-ahp-settings-"));
+	const path = join(root, "nested", "settings.json");
+	return {
+		path,
+		write(value) {
+			mkdirSync(dirname(path), { recursive: true });
+			writeFileSync(path, typeof value === "string" ? value : JSON.stringify(value));
+		},
+		close: () => rmSync(root, { recursive: true, force: true }),
+	};
+}
+
+describe("direct listener settings", () => {
+	it("creates a private, reusable endpoint configuration on first use", async () => {
+		const f = fixture();
+		try {
+			const settings = await loadDirectListenerSettings(f.path);
+			assert.equal(settings.host, "127.0.0.1");
+			assert.equal(Number.isInteger(settings.port) && settings.port >= 1 && settings.port <= 65_535, true);
+			assert.match(settings.token ?? "", /^[A-Za-z0-9_-]{43}$/u);
+			assert.deepEqual(JSON.parse(readFileSync(f.path, "utf8")), settings);
+			assert.equal(statSync(f.path).mode & 0o777, 0o600);
+			assert.deepEqual(await loadDirectListenerSettings(f.path), settings);
+		} finally {
+			f.close();
+		}
+	});
+
+	it("takes an existing file literally and defaults only optional fields", async () => {
+		const f = fixture();
+		try {
+			f.write({ port: 12345 });
+			assert.deepEqual(await loadDirectListenerSettings(f.path), {
+				port: 12345,
+				token: null,
+				host: "127.0.0.1",
+			});
+
+			f.write({ port: 23456, token: null, host: "0.0.0.0" });
+			assert.deepEqual(await loadDirectListenerSettings(f.path), {
+				port: 23456,
+				token: null,
+				host: "0.0.0.0",
+			});
+		} finally {
+			f.close();
+		}
+	});
+
+	it("rejects malformed or incomplete files instead of inventing replacements", async () => {
+		const f = fixture();
+		try {
+			const cases: Array<[unknown, RegExp]> = [
+				["not json", /not valid JSON/],
+				[{}, /no `port`/],
+				[{ port: 0 }, /integer 1-65535/],
+				[{ port: 65_536 }, /integer 1-65535/],
+				[{ port: 1.5 }, /integer 1-65535/],
+				[{ port: 12345, token: 42 }, /string or null/],
+				[{ port: 12345, host: 42 }, /host.*string/],
+			];
+			for (const [value, message] of cases) {
+				f.write(value);
+				await assert.rejects(
+					loadDirectListenerSettings(f.path),
+					(error: unknown) => error instanceof SettingsError && message.test(error.message),
+				);
+			}
+		} finally {
+			f.close();
+		}
+	});
+});