@danypops/pi-packed 0.19.7 → 0.19.10

package/service/test/install-validation.test.ts

@@ -0,0 +1,114 @@
+/**
+ * install-validation.test.ts — the real dry-run scenario: stage an actual
+ * npm tarball (via `npm pack` against a local fixture directory, so it's
+ * offline/deterministic -- npm pack works identically for a local path and
+ * a registry spec) and headlessly load-check it via pi-extension-harness's
+ * real mock-pi-cli subprocess. No mocking of npm, tar, or the harness --
+ * a broken fixture must genuinely be refused, a healthy one must genuinely
+ * pass.
+ */
+import { describe, expect, it } from "bun:test";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { InstallValidationResult, InstallValidator } from "../src/adoption/install-validation.ts";
+import { bareNpmSpec, HeadlessInstallValidator, validateExtensionLoadsHeadless } from "../src/adoption/install-validation.ts";
+import { ExecInstaller } from "../src/packages/install.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const FIXTURES = join(__dirname, "fixtures/install-validation");
+const HEALTHY = join(FIXTURES, "healthy-package");
+const BROKEN = join(FIXTURES, "broken-package");
+const NO_MANIFEST = join(FIXTURES, "no-manifest-package");
+
+describe("bareNpmSpec", () => {
+	it("strips the npm: scheme", () => {
+		expect(bareNpmSpec("npm:pi-lsp@1.0.0")).toBe("pi-lsp@1.0.0");
+	});
+
+	it("returns undefined for git:/https: sources -- out of scope for headless validation", () => {
+		expect(bareNpmSpec("git:github.com/u/r@main")).toBeUndefined();
+		expect(bareNpmSpec("https://example.com/pkg.tgz")).toBeUndefined();
+	});
+});
+
+describe("validateExtensionLoadsHeadless (real mock-pi-cli subprocess, no mocking)", () => {
+	it("reports ok for an extension that registers cleanly", async () => {
+		const result = await validateExtensionLoadsHeadless(join(HEALTHY, "extension/index.ts"));
+		expect(result.ok).toBe(true);
+	}, 20_000);
+
+	it("reports the real failure message for an extension that throws during registration", async () => {
+		const result = await validateExtensionLoadsHeadless(join(BROKEN, "extension/index.ts"));
+		expect(result.ok).toBe(false);
+		expect(result.message).toContain("deliberately fails during registration");
+	}, 20_000);
+});
+
+describe("HeadlessInstallValidator (real npm pack + tar extraction, no mocking)", () => {
+	it("passes through non-npm sources unchanged -- nothing to stage from an npm tarball", async () => {
+		const validator = new HeadlessInstallValidator();
+		const result = await validator.validate("git:github.com/u/r@main");
+		expect(result).toEqual({ ok: true, source: "git:github.com/u/r@main", extensions: [] });
+	});
+
+	it("passes a package with no pi.extensions -- most npm packages, nothing to validate", async () => {
+		const validator = new HeadlessInstallValidator();
+		const result = await validator.validate(`npm:${NO_MANIFEST}`);
+		expect(result.ok).toBe(true);
+		expect(result.extensions).toEqual([]);
+	}, 20_000);
+
+	it("refuses a real broken package, naming which extension failed and why", async () => {
+		const validator = new HeadlessInstallValidator();
+		const result = await validator.validate(`npm:${BROKEN}`);
+		expect(result.ok).toBe(false);
+		expect(result.extensions).toHaveLength(1);
+		expect(result.extensions[0]).toMatchObject({ path: "extension/index.ts", ok: false });
+		expect(result.extensions[0]?.message).toContain("deliberately fails during registration");
+	}, 20_000);
+
+	it("approves a real healthy package -- every declared extension reports ok", async () => {
+		const validator = new HeadlessInstallValidator();
+		const result = await validator.validate(`npm:${HEALTHY}`);
+		expect(result.ok).toBe(true);
+		expect(result.extensions).toEqual([{ path: "extension/index.ts", ok: true }]);
+	}, 20_000);
+});
+
+describe("ExecInstaller.install() -- refuses before ever spawning the real pi binary", () => {
+	function fakeValidator(result: InstallValidationResult): InstallValidator {
+		return { validate: async () => result };
+	}
+
+	it("never spawns pi when the validator reports a failed extension", async () => {
+		const installer = new ExecInstaller(
+			"/bin/false",
+			"/tmp/unused-pihome",
+			fakeValidator({
+				ok: false,
+				source: "npm:broken-pkg",
+				extensions: [{ path: "extension/index.ts", ok: false, message: "boom" }],
+			}),
+		);
+
+		await expect(installer.install("npm:broken-pkg")).rejects.toThrow(/install refused.*extension\/index\.ts: boom/);
+	});
+
+	it("proceeds to the real install when the validator approves", async () => {
+		// /bin/true always exits 0 -- proves the real spawn path was reached
+		// (a refused install never gets this far to find out).
+		const installer = new ExecInstaller(
+			"/bin/true",
+			"/tmp/unused-pihome",
+			fakeValidator({ ok: true, source: "npm:good-pkg", extensions: [] }),
+		);
+
+		await expect(installer.install("npm:good-pkg")).resolves.toBeDefined();
+	});
+
+	it("uses the real HeadlessInstallValidator by default, refusing a genuinely broken candidate end-to-end", async () => {
+		const installer = new ExecInstaller("/bin/true", "/tmp/unused-pihome");
+
+		await expect(installer.install(`npm:${BROKEN}`)).rejects.toThrow(/install refused/);
+	}, 20_000);
+});

package/service/test/install.test.ts

@@ -0,0 +1,113 @@
+/**
+ * ExecInstaller.update() — a real Bun.spawn subprocess round-trip, not a
+ * mocked one, matching the rest of this suite's real-I/O style.
+ *
+ * `pi update --extension <source>` was verified empirically (against the
+ * real `pi` binary) to exit 0 and print "Updated <source>" whether or not
+ * anything actually changed: both for a pinned, already-current source and
+ * for an unpinned, already-latest one. ExecInstaller must not trust that
+ * text; these tests drive a fake `pi` binary that reproduces the same
+ * always-"Updated"-regardless-of-outcome text, and assert the real on-disk
+ * version diff is what actually drives reloadRequired/alreadyUpToDate.
+ */
+import { describe, expect, it } from "bun:test";
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ExecInstaller } from "../src/packages/install.ts";
+
+/**
+ * A fake `pi` binary: always prints "Updated <source>" and exits 0 (matching
+ * real `pi`'s observed behavior for a no-op). When `rewrite` is given, it
+ * additionally overwrites that exact package's on-disk version -- letting a
+ * test simulate a genuine version change on demand. The rewrite target is
+ * baked into the script file itself (not an env var) so it is immune to
+ * Bun.spawn's default env snapshot not picking up late process.env writes.
+ */
+function writeFakePi(dir: string, rewrite?: { piHome: string; name: string; newVersion: string }): string {
+	const script = join(dir, "fake-pi");
+	const rewriteLine = rewrite
+		? `mkdir -p '${join(rewrite.piHome, "npm", "node_modules", rewrite.name)}' && printf '{"version":"%s"}' '${rewrite.newVersion}' > '${join(rewrite.piHome, "npm", "node_modules", rewrite.name, "package.json")}'`
+		: "true";
+	writeFileSync(
+		script,
+		// biome-ignore lint/suspicious/noTemplateCurlyInString: literal bash positional-parameter syntax in a generated fixture script, not JS interpolation
+		["#!/usr/bin/env bash", "set -euo pipefail", 'source="${3:-}"', rewriteLine, 'echo "Updated $source"', "exit 0"].join("\n"),
+	);
+	chmodSync(script, 0o755);
+	return script;
+}
+
+function writePiHome(nodeModules: Record<string, string> = {}): string {
+	const dir = mkdtempSync(join(tmpdir(), "packed-exec-pihome-"));
+	for (const [name, version] of Object.entries(nodeModules)) {
+		const pkgDir = join(dir, "npm", "node_modules", name);
+		mkdirSync(pkgDir, { recursive: true });
+		writeFileSync(join(pkgDir, "package.json"), JSON.stringify({ version }));
+	}
+	return dir;
+}
+
+describe("ExecInstaller.update() — honest reloadRequired despite pi's ambiguous exit-0 text", () => {
+	it("pinned source, version genuinely unchanged: alreadyUpToDate, reloadRequired false", async () => {
+		const scriptDir = mkdtempSync(join(tmpdir(), "packed-exec-bin-"));
+		const bin = writeFakePi(scriptDir);
+		const piHome = writePiHome({ "@scope/pkg": "1.2.3" });
+		const installer = new ExecInstaller(bin, piHome);
+
+		const outcome = await installer.update("npm:@scope/pkg@1.2.3");
+
+		expect(outcome.output).toBe("Updated npm:@scope/pkg@1.2.3");
+		expect(outcome.pinned).toBe(true);
+		expect(outcome.alreadyUpToDate).toBe(true);
+		expect(outcome.reloadRequired).toBe(false);
+		expect(outcome.previousVersion).toBe("1.2.3");
+		expect(outcome.currentVersion).toBe("1.2.3");
+	});
+
+	it('unpinned source, already latest (pi still exits 0 and says "Updated"): alreadyUpToDate', async () => {
+		const scriptDir = mkdtempSync(join(tmpdir(), "packed-exec-bin-"));
+		const bin = writeFakePi(scriptDir);
+		const piHome = writePiHome({ plain: "0.5.0" });
+		const installer = new ExecInstaller(bin, piHome);
+
+		const outcome = await installer.update("npm:plain");
+
+		expect(outcome.pinned).toBe(false);
+		expect(outcome.alreadyUpToDate).toBe(true);
+		expect(outcome.reloadRequired).toBe(false);
+		expect(outcome.previousVersion).toBe("0.5.0");
+		expect(outcome.currentVersion).toBe("0.5.0");
+	});
+
+	it("unpinned source, a real version change happens: reloadRequired true", async () => {
+		const scriptDir = mkdtempSync(join(tmpdir(), "packed-exec-bin-"));
+		const piHome = writePiHome({ plain: "0.5.0" });
+		const bin = writeFakePi(scriptDir, { piHome, name: "plain", newVersion: "0.6.0" });
+		const installer = new ExecInstaller(bin, piHome);
+
+		const outcome = await installer.update("npm:plain");
+
+		expect(outcome.alreadyUpToDate).toBe(false);
+		expect(outcome.reloadRequired).toBe(true);
+		expect(outcome.previousVersion).toBe("0.5.0");
+		expect(outcome.currentVersion).toBe("0.6.0");
+		expect(readFileSync(join(piHome, "npm", "node_modules", "plain", "package.json"), "utf8")).toContain("0.6.0");
+	});
+
+	it("git: source (no npm resolution possible either side): conservatively assumes it may have changed", async () => {
+		const scriptDir = mkdtempSync(join(tmpdir(), "packed-exec-bin-"));
+		const bin = writeFakePi(scriptDir);
+		const piHome = writePiHome();
+		const installer = new ExecInstaller(bin, piHome);
+
+		const outcome = await installer.update("git:github.com/u/r@main");
+
+		expect(outcome.pinned).toBe(false);
+		expect(outcome.previousVersion).toBeUndefined();
+		expect(outcome.currentVersion).toBeUndefined();
+		// No ground truth either side -- must not falsely claim nothing changed.
+		expect(outcome.alreadyUpToDate).toBe(false);
+		expect(outcome.reloadRequired).toBe(true);
+	});
+});

package/service/test/log.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "bun:test";
+import { createLogger, type LogSink } from "../src/shared/log.ts";
+
+function capture(): { lines: string[]; sink: LogSink } {
+	const lines: string[] = [];
+	return { lines, sink: (l) => lines.push(l) };
+}
+
+describe("logger", () => {
+	it("emits daemon-kit structured JSON with component, level, message, and fields", () => {
+		const { lines, sink } = capture();
+		const log = createLogger("test", sink, "debug");
+		log.info("page fetched", { from: 250, status: 200, ms: 42 });
+		const entry = JSON.parse(lines[0]!);
+		expect(entry).toMatchObject({ level: "info", component: "test", msg: "page fetched", from: 250, status: 200, ms: 42 });
+		expect(entry.timestamp).toBeTruthy();
+	});
+
+	it("filters below the minimum level", () => {
+		const { lines, sink } = capture();
+		const log = createLogger("test", sink, "info");
+		log.debug("noisy");
+		log.info("kept");
+		expect(lines).toHaveLength(1);
+		expect(JSON.parse(lines[0]!).msg).toBe("kept");
+	});
+
+	it("warn and error always pass at info level", () => {
+		const { lines, sink } = capture();
+		const log = createLogger("test", sink, "info");
+		log.warn("w");
+		log.error("e");
+		expect(lines).toHaveLength(2);
+	});
+
+	it("fields are optional", () => {
+		const { lines, sink } = capture();
+		const log = createLogger("test", sink, "debug");
+		log.debug("plain");
+		expect(JSON.parse(lines[0]!).msg).toBe("plain");
+	});
+});