@danypops/pi-packed 0.19.12 → 0.20.0

package/service/test/service.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "bun:test";
-import { mkdtempSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { ServiceSpec } from "@danypops/vehicle-server/service";
@@ -62,30 +62,45 @@ class FakeDaemonServiceInstaller implements DaemonServiceInstaller {
 	gotPiHome = "";
 	gotSource = "";
 	resolveFailure: string | undefined;
+	notADaemon = false;
 	installFailure: string | undefined;
+	removeGotPiHome = "";
+	removeGotSource = "";
 	restartGotPiHome = "";
 	restartGotSource = "";
 	restartResolveFailure: string | undefined;
+	restartNotADaemon = false;
 	restartReason: string | undefined;
 	restarted = true;
-	spec: ServiceSpec = { name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" };
-	install(
+	spec: ServiceSpec = {
+		name: "probe",
+		version: "1.0.0",
+		binPath: "/opt/probe/cli.js",
+		handlePath: "/tmp/probe.handle.json",
+	};
+	async install(
 		piHome: string,
 		source: string,
-	): { ok: true; result: { installed: true } | { installed: false; reason: string }; spec: ServiceSpec } | { ok: false; reason: string } {
+	): Promise<{ ok: true; result: { installed: true } | { installed: false; reason: string }; spec: ServiceSpec } | { ok: false; reason: string }> {
 		this.gotPiHome = piHome;
 		this.gotSource = source;
-		if (this.resolveFailure) return { ok: false, reason: this.resolveFailure };
+		if (this.resolveFailure) return { ok: false, reason: this.resolveFailure, ...(this.notADaemon ? { notADaemon: true } : {}) };
 		if (this.installFailure) return { ok: true, result: { installed: false, reason: this.installFailure }, spec: this.spec };
 		return { ok: true, result: { installed: true }, spec: this.spec };
 	}
-	restart(
+	async remove(piHome: string, source: string): Promise<{ ok: true; result: { installed: true }; spec: ServiceSpec }> {
+		this.removeGotPiHome = piHome;
+		this.removeGotSource = source;
+		return { ok: true, result: { installed: true }, spec: this.spec };
+	}
+	async restart(
 		piHome: string,
 		source: string,
-	): { ok: true; restarted: boolean; reason?: string; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean } {
+	): Promise<{ ok: true; restarted: boolean; reason?: string; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }> {
 		this.restartGotPiHome = piHome;
 		this.restartGotSource = source;
-		if (this.restartResolveFailure) return { ok: false, reason: this.restartResolveFailure };
+		if (this.restartResolveFailure)
+			return { ok: false, reason: this.restartResolveFailure, ...(this.restartNotADaemon ? { notADaemon: true } : {}) };
 		return { ok: true, restarted: this.restarted, reason: this.restartReason, spec: this.spec };
 	}
 }
@@ -224,7 +239,10 @@ describe("service app", () => {
 
 	it("POST /install accepts valid sources, reports failures in-band", async () => {
 		const inst = new FakeInstaller();
-		const app = createApp(deps({ inst }));
+		const service = new FakeDaemonServiceInstaller();
+		service.resolveFailure = "not a Vehicle";
+		service.notADaemon = true;
+		const app = createApp(deps({ inst, daemonServiceInstaller: service }));
 		for (const source of ["npm:foo", "npm:@scope/pkg@1.2.3", "git:github.com/u/r@v1", "https://github.com/u/r"]) {
 			const res = await app.fetch(
 				new Request("http://x/install", {
@@ -252,6 +270,23 @@ describe("service app", () => {
 		expect(body.output).toContain("npm ERR! 404");
 	});
 
+	it("POST /install configures an npm package's persistent Vehicle under the same approval", async () => {
+		const svc = new FakeDaemonServiceInstaller();
+		const piHome = mkdtempSync(join(tmpdir(), "packed-install-vehicle-"));
+		const app = createApp(deps({ daemonServiceInstaller: svc, piHome }));
+		const response = await app.fetch(
+			new Request("http://x/install", {
+				method: "POST",
+				headers: { ...auth, "content-type": "application/json" },
+				body: JSON.stringify({ source: "npm:probe", approved: true }),
+			}),
+		);
+		expect(response.status).toBe(200);
+		expect(await response.json()).toMatchObject({ ok: true, service: { name: "probe", binPath: "/opt/probe/cli.js" } });
+		expect(svc.gotPiHome).toBe(piHome);
+		expect(svc.gotSource).toBe("npm:probe");
+	});
+
 	it("POST /install-service rejects invalid sources and requires approval, matching /install's own guard", async () => {
 		const svc = new FakeDaemonServiceInstaller();
 		const app = createApp(deps({ daemonServiceInstaller: svc }));
@@ -307,7 +342,7 @@ describe("service app", () => {
 		const body = (await res.json()) as any;
 		expect(body.ok).toBe(true);
 		expect(body.output).toContain("probe");
-		expect(body.spec).toEqual({ name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" });
+		expect(body.spec).toEqual({ name: "probe", binPath: "/opt/probe/cli.js" });
 		expect(svc.gotPiHome).toBe(piHome);
 		expect(svc.gotSource).toBe("npm:web-spider-daemon");
 	});
@@ -340,7 +375,7 @@ describe("service app", () => {
 		const body = (await installFailure.json()) as any;
 		expect(body.ok).toBe(false);
 		expect(body.output).toContain("no supported Linux init system");
-		expect(body.spec).toEqual({ name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" });
+		expect(body.spec).toEqual({ name: "probe", binPath: "/opt/probe/cli.js" });
 	});
 
 	it("POST /restart-service rejects invalid sources and requires approval, matching /install-service's own guard", async () => {
@@ -385,7 +420,7 @@ describe("service app", () => {
 		const body = (await res.json()) as any;
 		expect(body.ok).toBe(true);
 		expect(body.restarted).toBe(true);
-		expect(body.spec).toEqual({ name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" });
+		expect(body.spec).toEqual({ name: "probe", binPath: "/opt/probe/cli.js" });
 		expect(svc.restartGotPiHome).toBe(piHome);
 		expect(svc.restartGotSource).toBe("npm:web-spider-daemon");
 	});
@@ -424,7 +459,10 @@ describe("service app", () => {
 
 	it("POST /update validates, authorizes, and delegates one Pi package source", async () => {
 		const inst = new FakeInstaller();
-		const app = createApp(deps({ inst }));
+		const service = new FakeDaemonServiceInstaller();
+		service.restartResolveFailure = "not a Vehicle";
+		service.restartNotADaemon = true;
+		const app = createApp(deps({ inst, daemonServiceInstaller: service }));
 		const denied = await app.fetch(
 			new Request("http://x/update", {
 				method: "POST",
@@ -452,6 +490,22 @@ describe("service app", () => {
 		expect(inst.updated).toBe("npm:pi-lsp");
 	});
 
+	it("POST /update reconciles an installed Vehicle after a real package change", async () => {
+		const svc = new FakeDaemonServiceInstaller();
+		const piHome = mkdtempSync(join(tmpdir(), "packed-update-vehicle-"));
+		const app = createApp(deps({ daemonServiceInstaller: svc, piHome }));
+		const response = await app.fetch(
+			new Request("http://x/update", {
+				method: "POST",
+				headers: { ...auth, "content-type": "application/json" },
+				body: JSON.stringify({ source: "npm:probe", approved: true }),
+			}),
+		);
+		expect(await response.json()).toMatchObject({ ok: true, serviceReconciled: true });
+		expect(svc.restartGotPiHome).toBe(piHome);
+		expect(svc.restartGotSource).toBe("npm:probe");
+	});
+
 	it("POST /update reports an honest no-op instead of trusting pi's always-0-exit-code text", async () => {
 		const inst = new FakeInstaller();
 		inst.updateOutcome = { reloadRequired: false, alreadyUpToDate: true, pinned: true, previousVersion: "1.0.0", currentVersion: "1.0.0" };
@@ -527,6 +581,28 @@ describe("service app", () => {
 		expect(inst.removed).toBe("npm:pi-lsp");
 	});
 
+	it("POST /remove removes declared Vehicle state before deleting the package", async () => {
+		const piHome = mkdtempSync(join(tmpdir(), "packed-remove-vehicle-"));
+		const packageDir = join(piHome, "npm", "node_modules", "probe");
+		mkdirSync(packageDir, { recursive: true });
+		writeFileSync(
+			join(packageDir, "package.json"),
+			JSON.stringify({ name: "probe", version: "1.0.0", packed: { daemonService: { binPath: "cli.js" } } }),
+		);
+		const svc = new FakeDaemonServiceInstaller();
+		const app = createApp(deps({ piHome, daemonServiceInstaller: svc }));
+		const response = await app.fetch(
+			new Request("http://x/remove", {
+				method: "POST",
+				headers: { ...auth, "content-type": "application/json" },
+				body: JSON.stringify({ name: "probe", approved: true }),
+			}),
+		);
+		expect((await response.json()) as unknown).toMatchObject({ ok: true, serviceRemoved: true });
+		expect(svc.removeGotPiHome).toBe(piHome);
+		expect(svc.removeGotSource).toBe("npm:probe");
+	});
+
 	it("GET /catalog serves the SQLite mirror", async () => {
 		const d = deps();
 		const db = openDb(dbPath(d.stateDir));

package/service/test/vehicle-registration.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, it } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { OPERATION_NAMES } from "../src/daemon/service.ts";
+import { createApp, type Deps } from "../src/daemon/service.ts";
+import type { Installer, Pkg, PkgInfo, Registry, SearchPage, UpdateOutcome } from "../src/packages/package.ts";
+
+class FakeRegistry implements Registry {
+	constructor(
+		private results: Pkg[] = [],
+		private total = 0,
+	) {}
+	async search(query: string, limit: number): Promise<SearchPage> {
+		return { results: this.results, total: this.total };
+	}
+	async searchPage(): Promise<SearchPage> {
+		return { results: this.results, total: this.total };
+	}
+	async searchAll(): Promise<Pkg[]> {
+		return this.results;
+	}
+	async info(name: string): Promise<PkgInfo> {
+		return { name, version: "1.0.0" };
+	}
+}
+
+class FakeInstaller implements Installer {
+	async install(source: string): Promise<string> {
+		return `installed ${source}`;
+	}
+	async remove(source: string): Promise<string> {
+		return `removed ${source}`;
+	}
+	async update(source: string): Promise<UpdateOutcome> {
+		return { output: `updated ${source}`, reloadRequired: true, alreadyUpToDate: false, pinned: false };
+	}
+}
+
+function deps(over: Partial<Deps> = {}): Deps {
+	return {
+		reg: new FakeRegistry([{ name: "pi-lsp", version: "1.0.0", description: "An LSP package" }], 1),
+		inst: new FakeInstaller(),
+		token: "test-token",
+		stateDir: mkdtempSync(join(tmpdir(), "packed-vehicle-")),
+		...over,
+	};
+}
+
+async function invoke(app: { fetch(request: Request): Promise<Response> }, name: string, input: Record<string, unknown>, token = "test-token") {
+	const response = await app.fetch(
+		new Request("http://packed.internal/vehicle/invoke", {
+			method: "POST",
+			headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+			body: JSON.stringify({ name, version: 1, input, permissions: ["packed:read", "packed:write"] }),
+		}),
+	);
+	return { status: response.status, body: (await response.json()) as { output?: unknown; error?: { category: string; message: string } } };
+}
+
+describe("packed's daemon operation surface, through the real Vehicle wire protocol", () => {
+	it("GET /vehicle/manifest lists all 29 operations, authenticated the same as /api/v1/ops", async () => {
+		const app = createApp(deps());
+		const unauthorized = await app.fetch(new Request("http://packed.internal/vehicle/manifest"));
+		expect(unauthorized.status).toBe(401);
+		const response = await app.fetch(new Request("http://packed.internal/vehicle/manifest", { headers: { authorization: "Bearer test-token" } }));
+		expect(response.status).toBe(200);
+		const body = (await response.json()) as { operations: Array<{ name: string }> };
+		expect(body.operations.map((o) => o.name).sort()).toEqual([...OPERATION_NAMES].sort());
+	});
+
+	it("package.search round-trips through /vehicle/invoke, matching /api/v1/ops's own shape", async () => {
+		const app = createApp(deps());
+		const result = await invoke(app, "package.search", { query: "lsp", limit: 10 });
+		expect(result.status).toBe(200);
+		expect((result.body.output as { total: number }).total).toBe(1);
+		expect((result.body.output as { results: Array<{ name: string }> }).results[0]?.name).toBe("pi-lsp");
+	});
+
+	it("package.installed and pi.status (daemon-only, never a Pi tool) are still reachable through /vehicle/invoke", async () => {
+		const app = createApp(deps({ piHome: mkdtempSync(join(tmpdir(), "packed-vehicle-pihome-")) }));
+		const installed = await invoke(app, "package.installed", {});
+		expect(installed.status).toBe(200);
+		expect(installed.body.output).toEqual([]);
+	});
+
+	it("a denied mutation (default mutationApproval: always, no approved flag) surfaces Vehicle's authorization category -> HTTP 403, same as /api/v1/ops's own 403", async () => {
+		const app = createApp(deps());
+		const result = await invoke(app, "package.remove", { name: "pi-lsp" });
+		expect(result.status).toBe(403);
+		expect(result.body.error?.category).toBe("authorization");
+	});
+
+	it("an approved mutation succeeds through /vehicle/invoke exactly like an approved /api/v1/ops call", async () => {
+		const app = createApp(deps());
+		const result = await invoke(app, "package.remove", { name: "pi-lsp", approved: true });
+		expect(result.status).toBe(200);
+		expect((result.body.output as { ok: boolean }).ok).toBe(true);
+	});
+
+	it("a handler-thrown validation error keeps its own real message, mapped to Vehicle's validation category (not a generic internal 500)", async () => {
+		const app = createApp(deps());
+		const result = await invoke(app, "package.check", { path: "" });
+		expect(result.status).toBe(400);
+		expect(result.body.error?.category).toBe("validation");
+		expect(result.body.error?.message).toContain("path must be a non-empty string");
+	});
+
+	it("the old /api/v1/ops route keeps working unchanged, alongside /vehicle/invoke", async () => {
+		const app = createApp(deps());
+		const legacy = await app.fetch(
+			new Request("http://packed.internal/api/v1/ops", {
+				method: "POST",
+				headers: { authorization: "Bearer test-token", "content-type": "application/json" },
+				body: JSON.stringify({ op: "package.search", input: { query: "lsp", limit: 10 } }),
+			}),
+		);
+		expect(legacy.status).toBe(200);
+		expect(((await legacy.json()) as { result: { total: number } }).result.total).toBe(1);
+	});
+});