@danypops/pi-packed 0.19.12 → 0.20.1

package/service/test/cli.test.ts

@@ -79,29 +79,48 @@ class FakeDaemonServiceInstaller {
 	restartGotSource = "";
 	restartApproved = false;
 	restartFail = false;
-	async install(
-		source: string,
-		approved?: boolean,
-	): Promise<{ output: string; spec?: { name: string; binPath: string; descriptorPath: string } }> {
+	reconcileGotApproved: boolean | undefined;
+	reconcileGotProjectRoot: string | undefined;
+	reconcileFail = false;
+	async install(source: string, approved?: boolean) {
 		this.gotSource = source;
 		this.approved = approved === true;
 		if (this.fail) throw new Error("install-service failed");
 		return {
 			output: `installed a persistent service for ${source}`,
-			spec: { name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" },
+			spec: {
+				name: "probe",
+				version: "1.0.0",
+				binPath: "/opt/probe/cli.js",
+				handlePath: "/tmp/probe.handle.json",
+			},
 		};
 	}
-	async restart(
-		source: string,
-		approved?: boolean,
-	): Promise<{ output: string; restarted?: boolean; spec?: { name: string; binPath: string; descriptorPath: string } }> {
+	async restart(source: string, approved?: boolean) {
 		this.restartGotSource = source;
 		this.restartApproved = approved === true;
 		if (this.restartFail) throw new Error("restart-service failed");
 		return {
 			output: `restarted the persistent service for ${source}`,
 			restarted: true,
-			spec: { name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" },
+			spec: {
+				name: "probe",
+				version: "1.0.0",
+				binPath: "/opt/probe/cli.js",
+				handlePath: "/tmp/probe.handle.json",
+			},
+		};
+	}
+	async reconcileAll(approved?: boolean, projectRoot?: string) {
+		this.reconcileGotApproved = approved;
+		this.reconcileGotProjectRoot = projectRoot;
+		if (this.reconcileFail) throw new Error("reconcile-services failed");
+		return {
+			ok: true,
+			output: "reconciled 1 Vehicle(s), skipped 0 non-daemon package(s)",
+			reconciled: [{ packageName: "@danypops/probe", vehicleName: "probe", installed: true }],
+			skipped: 0,
+			failed: [],
 		};
 	}
 }
@@ -454,67 +473,15 @@ describe("CLI", () => {
 	it("install runs with stable human and JSON output", async () => {
 		const d = deps();
 		expect((await cliRun(["install", "npm:foo"], d)).code).toBe(1);
-		// --no-service scopes this test to the base install output; service
-		// auto-registration composition has its own dedicated tests below.
-		const human = await cliRun(["install", "npm:foo", "--approve", "--no-service"], d);
+		const human = await cliRun(["install", "npm:foo", "--approve"], d);
 		expect(human.code).toBe(0);
 		expect(human.out).toContain("Installed npm:foo");
 		expect((d.inst as FakeInstaller).approved).toBe(true);
-		const json = await cliRun(["install", "npm:foo", "--approve", "--no-service", "--json"], d);
+		const json = await cliRun(["install", "npm:foo", "--approve", "--json"], d);
 		expect(json.code).toBe(0);
 		expect(JSON.parse(json.out)).toEqual({ ok: true, source: "npm:foo", output: "Installed npm:foo" });
 	});
 
-	it("install auto-registers a detected daemon service under the same approval, silently for a non-daemon package", async () => {
-		const d = deps();
-		const human = await cliRun(["install", "npm:foo", "--approve"], d);
-		expect(human.code).toBe(0);
-		expect(human.out).toContain("Installed npm:foo");
-		expect(human.out).toContain("installed a persistent service for npm:foo");
-		expect((d.daemonService as FakeDaemonServiceInstaller).approved).toBe(true);
-		const json = await cliRun(["install", "npm:foo", "--approve", "--json"], d);
-		expect(json.code).toBe(0);
-		expect(JSON.parse(json.out)).toEqual({
-			ok: true,
-			source: "npm:foo",
-			output: "Installed npm:foo",
-			serviceInstall: { detected: true, ok: true, output: "installed a persistent service for npm:foo" },
-		});
-
-		// notADaemon: the overwhelmingly common case (an ordinary, non-daemon package) stays silent.
-		const notADaemon = deps();
-		(notADaemon.daemonService as FakeDaemonServiceInstaller).install = async () => {
-			throw Object.assign(
-				new Error("foo does not declare a packed.daemonService manifest and no Vehicle-shaped daemon dependency was detected"),
-				{ notADaemon: true },
-			);
-		};
-		const silent = await cliRun(["install", "npm:foo", "--approve", "--json"], notADaemon);
-		expect(JSON.parse(silent.out)).toEqual({ ok: true, source: "npm:foo", output: "Installed npm:foo" });
-
-		// A genuine failure (a daemon was detected but registration itself failed) is reported
-		// without failing the install, which already succeeded.
-		const realFailure = deps();
-		(realFailure.daemonService as FakeDaemonServiceInstaller).fail = true;
-		const failed = await cliRun(["install", "npm:foo", "--approve", "--json"], realFailure);
-		expect(failed.code).toBe(0);
-		expect(JSON.parse(failed.out)).toEqual({
-			ok: true,
-			source: "npm:foo",
-			output: "Installed npm:foo",
-			serviceInstall: { detected: true, ok: false, output: "install-service failed" },
-		});
-
-		// --no-service skips the attempt entirely -- the daemonService fake is never called.
-		const skipped = deps();
-		await cliRun(["install", "npm:foo", "--approve", "--no-service"], skipped);
-		expect((skipped.daemonService as FakeDaemonServiceInstaller).gotSource).toBe("");
-
-		// A non-npm source never attempts service detection -- daemon-service resolution only supports npm: today.
-		const gitSource = deps();
-		await cliRun(["install", "git:github.com/u/r@v1", "--approve"], gitSource);
-		expect((gitSource.daemonService as FakeDaemonServiceInstaller).gotSource).toBe("");
-	});
 
 	it("install-service validates source", async () => {
 		const d = deps();
@@ -536,7 +503,12 @@ describe("CLI", () => {
 			ok: true,
 			source: "npm:foo",
 			output: "installed a persistent service for npm:foo",
-			spec: { name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" },
+			spec: {
+				name: "probe",
+				version: "1.0.0",
+				binPath: "/opt/probe/cli.js",
+				handlePath: "/tmp/probe.handle.json",
+			},
 		});
 	});
 
@@ -555,33 +527,52 @@ describe("CLI", () => {
 		expect(out).toContain("requires a running packed daemon");
 	});
 
-	it("update delegates one configured source with stable output and approval", async () => {
+	it("reconcile-services requires approval, then sweeps every installed package with stable human and JSON output", async () => {
 		const d = deps();
-		expect((await cliRun(["update", "npm:foo"], d)).code).toBe(1);
-		// --no-service scopes this test to the base update output; service restart
-		// composition has its own dedicated test below, mirroring install's own split.
-		const human = await cliRun(["update", "npm:foo", "--approve", "--no-service"], d);
-		expect(human.out).toContain("Updated npm:foo");
-		expect((d.inst as FakeInstaller).updated).toBe("npm:foo");
-		expect((d.inst as FakeInstaller).approved).toBe(true);
-		const json = await cliRun(["update", "npm:foo", "--approve", "--no-service", "--json"], d);
+		expect((await cliRun(["reconcile-services"], d)).code).toBe(1);
+		const human = await cliRun(["reconcile-services", "--approve"], d);
+		expect(human.code).toBe(0);
+		expect(human.out).toContain("reconciled 1 Vehicle(s)");
+		expect((d.daemonService as FakeDaemonServiceInstaller).reconcileGotApproved).toBe(true);
+		const json = await cliRun(["reconcile-services", "--approve", "--json"], d);
+		expect(json.code).toBe(0);
 		expect(JSON.parse(json.out)).toEqual({
 			ok: true,
-			source: "npm:foo",
-			output: "Updated npm:foo",
-			reloadRequired: true,
-			alreadyUpToDate: false,
-			pinned: false,
+			output: "reconciled 1 Vehicle(s), skipped 0 non-daemon package(s)",
+			reconciled: [{ packageName: "@danypops/probe", vehicleName: "probe", installed: true }],
+			skipped: 0,
+			failed: [],
 		});
 	});
 
-	it("update restarts a registered daemon service after a real change, silently for a non-daemon package", async () => {
+	it("reconcile-services threads --project through to the sweep", async () => {
+		const d = deps();
+		await cliRun(["reconcile-services", "--approve", "--project", "/repo"], d);
+		expect((d.daemonService as FakeDaemonServiceInstaller).reconcileGotProjectRoot).toBe("/repo");
+	});
+
+	it("reconcile-services reports a sweep failure in-band with exit code 1", async () => {
+		const d = deps();
+		(d.daemonService as FakeDaemonServiceInstaller).reconcileFail = true;
+		const { code, out } = await cliRun(["reconcile-services", "--approve"], d);
+		expect(code).toBe(1);
+		expect(out).toContain("reconcile-services failed");
+	});
+
+	it("reconcile-services fails closed without a running daemon", async () => {
+		const d = deps({ daemonService: undefined });
+		const { code, out } = await cliRun(["reconcile-services", "--approve"], d);
+		expect(code).toBe(1);
+		expect(out).toContain("requires a running packed daemon");
+	});
+
+	it("update delegates one configured source with stable output and approval", async () => {
 		const d = deps();
+		expect((await cliRun(["update", "npm:foo"], d)).code).toBe(1);
 		const human = await cliRun(["update", "npm:foo", "--approve"], d);
-		expect(human.code).toBe(0);
 		expect(human.out).toContain("Updated npm:foo");
-		expect(human.out).toContain("restarted the persistent service for npm:foo");
-		expect((d.daemonService as FakeDaemonServiceInstaller).restartApproved).toBe(true);
+		expect((d.inst as FakeInstaller).updated).toBe("npm:foo");
+		expect((d.inst as FakeInstaller).approved).toBe(true);
 		const json = await cliRun(["update", "npm:foo", "--approve", "--json"], d);
 		expect(JSON.parse(json.out)).toEqual({
 			ok: true,
@@ -590,47 +581,10 @@ describe("CLI", () => {
 			reloadRequired: true,
 			alreadyUpToDate: false,
 			pinned: false,
-			serviceRestart: { detected: true, ok: true, output: "restarted the persistent service for npm:foo" },
 		});
-
-		// notADaemon: the overwhelmingly common case (an ordinary, non-daemon package) stays silent.
-		const notADaemon = deps();
-		(notADaemon.daemonService as FakeDaemonServiceInstaller).restart = async () => {
-			throw Object.assign(
-				new Error("foo does not declare a packed.daemonService manifest and no Vehicle-shaped daemon dependency was detected"),
-				{ notADaemon: true },
-			);
-		};
-		const silent = await cliRun(["update", "npm:foo", "--approve", "--json"], notADaemon);
-		expect(JSON.parse(silent.out)).toEqual({
-			ok: true,
-			source: "npm:foo",
-			output: "Updated npm:foo",
-			reloadRequired: true,
-			alreadyUpToDate: false,
-			pinned: false,
-		});
-
-		// A genuine failure (a daemon was detected but restarting it failed) is reported
-		// without failing the update, which already succeeded.
-		const realFailure = deps();
-		(realFailure.daemonService as FakeDaemonServiceInstaller).restartFail = true;
-		const failed = await cliRun(["update", "npm:foo", "--approve", "--json"], realFailure);
-		expect(failed.code).toBe(0);
-		const failedBody = JSON.parse(failed.out);
-		expect(failedBody.serviceRestart).toEqual({ detected: true, ok: false, output: "restart-service failed" });
-
-		// --no-service skips the attempt entirely -- the daemonService fake is never called.
-		const skipped = deps();
-		await cliRun(["update", "npm:foo", "--approve", "--no-service"], skipped);
-		expect((skipped.daemonService as FakeDaemonServiceInstaller).restartGotSource).toBe("");
-
-		// A non-npm source never attempts service detection -- daemon-service resolution only supports npm: today.
-		const gitSource = deps({ inst: new FakeInstaller() });
-		await cliRun(["update", "git:github.com/u/r@v1", "--approve"], gitSource);
-		expect((gitSource.daemonService as FakeDaemonServiceInstaller).restartGotSource).toBe("");
 	});
 
+
 	it("update --self requires approval under the guarded default, same as every other mutation", async () => {
 		const d = deps({
 			selfUpdater: {
@@ -851,19 +805,36 @@ describe("CLI", () => {
 			},
 			async installService(source) {
 				calls.push(`installService:${source}`);
-				return { output: source, spec: { name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" } };
+				return {
+					output: source,
+					spec: {
+						name: "probe",
+						version: "1.0.0",
+						binPath: "/opt/probe/cli.js",
+						handlePath: "/tmp/probe.handle.json",
+					},
+				};
 			},
 			async restartService(source) {
 				calls.push(`restartService:${source}`);
 				return {
 					output: source,
 					restarted: true,
-					spec: { name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/tmp/probe.service" },
+					spec: {
+						name: "probe",
+						version: "1.0.0",
+						binPath: "/opt/probe/cli.js",
+						handlePath: "/tmp/probe.handle.json",
+					},
 				};
 			},
 			async remove(name) {
 				return name;
 			},
+			async reconcileServices(approved, projectRoot) {
+				calls.push(`reconcileServices:${approved}:${projectRoot}`);
+				return { ok: true, output: "reconciled 0 Vehicle(s), skipped 0 non-daemon package(s)", reconciled: [], skipped: 0, failed: [] };
+			},
 			async update(source) {
 				return { output: source, reloadRequired: false, alreadyUpToDate: true, pinned: false };
 			},
@@ -1050,7 +1021,7 @@ describe("CLI", () => {
 			const d = deps({ piHome });
 
 			const clean = await cliRun(["doctor", "--json"], d);
-			expect(clean.code).toBe(0);
+			expect(clean.code, clean.out).toBe(0);
 			expect(JSON.parse(clean.out)).toMatchObject({ ok: true, conflicts: [] });
 
 			const withProject = await cliRun(["doctor", "--project", projectRoot, "--json"], d);
@@ -1105,16 +1076,27 @@ describe("daemon client", () => {
 			reg: new FakeRegistry([{ name: "pi-lsp", version: "0.3.0" }]),
 			inst: daemonInstaller,
 			daemonServiceInstaller: {
-				install: () => ({
-					ok: true,
-					result: { installed: true },
-					spec: { name: "pi-lsp", binPath: "/opt/pi-lsp/cli.js", descriptorPath: "/tmp/pi-lsp.service" },
-				}),
-				restart: () => ({
-					ok: true,
-					restarted: true,
-					spec: { name: "pi-lsp", binPath: "/opt/pi-lsp/cli.js", descriptorPath: "/tmp/pi-lsp.service" },
-				}),
+				async install() {
+					return {
+						ok: true,
+						result: { installed: true },
+						spec: { name: "pi-lsp", version: "1.0.0", binPath: "/opt/pi-lsp/cli.js", handlePath: "/tmp/pi-lsp.handle.json" },
+					};
+				},
+				async remove() {
+					return {
+						ok: true,
+						result: { installed: true },
+						spec: { name: "pi-lsp", version: "1.0.0", binPath: "/opt/pi-lsp/cli.js", handlePath: "/tmp/pi-lsp.handle.json" },
+					};
+				},
+				async restart() {
+					return {
+						ok: true,
+						restarted: true,
+						spec: { name: "pi-lsp", version: "1.0.0", binPath: "/opt/pi-lsp/cli.js", handlePath: "/tmp/pi-lsp.handle.json" },
+					};
+				},
 			},
 			token: daemonToken,
 			stateDir: daemonDir,
@@ -1244,11 +1226,11 @@ describe("daemon client", () => {
 		expect((await client.setupApply(`${checkRoot}/pi-setup.json`, true)).ok).toBe(true);
 		expect(await client.security()).toEqual({ mutationApproval: "always" });
 		await expect(client.install("npm:pi-lsp")).rejects.toThrow("approval required");
-		expect(await client.install("npm:pi-lsp", true)).toBe("Installed npm:pi-lsp");
+		expect(await client.install("npm:pi-lsp", true)).toBe("Installed npm:pi-lsp\ninstalled persistent Vehicle pi-lsp");
 		await expect(client.installService("npm:pi-lsp")).rejects.toThrow("approval required");
 		expect(await client.installService("npm:pi-lsp", true)).toEqual({
 			output: "installed a persistent service for pi-lsp",
-			spec: { name: "pi-lsp", binPath: "/opt/pi-lsp/cli.js", descriptorPath: "/tmp/pi-lsp.service" },
+			spec: { name: "pi-lsp", binPath: "/opt/pi-lsp/cli.js" },
 		});
 		expect(await client.remove("pi-lsp", true)).toBe("Removed npm:pi-lsp");
 		expect(await client.piStatus()).toEqual({ current: "0.82.1", latest: "0.83.0", upToDate: false });
@@ -1261,7 +1243,9 @@ describe("daemon client", () => {
 			currentVersion: undefined,
 		});
 		const installer = new PackageDaemonInstaller(client);
-		expect(await installer.install("npm:pi-lsp@1.0.0", { approved: true })).toBe("Installed npm:pi-lsp@1.0.0");
+		expect(await installer.install("npm:pi-lsp@1.0.0", { approved: true })).toBe(
+			"Installed npm:pi-lsp@1.0.0\ninstalled persistent Vehicle pi-lsp",
+		);
 		expect(await installer.remove("npm:pi-lsp", { approved: true })).toBe("Removed npm:pi-lsp");
 		expect((await installer.update("npm:pi-lsp", { approved: true })).output).toBe("Updated npm:pi-lsp");
 		expect(await client.setMutationApproval("never", true)).toEqual({ mutationApproval: "never" });

package/service/test/daemon-kit-migration.test.ts

@@ -142,6 +142,7 @@ describe("daemon-kit migration", () => {
 			"package.install",
 			"package.install_service",
 			"package.restart_service",
+			"package.reconcile_services",
 			"package.remove",
 			"package.update",
 			"resources.list",

package/service/test/daemon-maintenance.test.ts

@@ -0,0 +1,127 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ServiceInstallResult, ServiceSpec } from "@danypops/vehicle-server/service";
+import { daemonOptions } from "../src/daemon/daemon.ts";
+import type { Installer, Registry } from "../src/packages/package.ts";
+import { RECONCILE_INTERVAL_DEFAULT_MS } from "../src/shared/constants.ts";
+import { resolvePackedPaths } from "../src/shared/paths.ts";
+
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+function fakePiHome(packages: string[]): string {
+	const piHome = mkdtempSync(join(tmpdir(), "packed-maintenance-"));
+	roots.push(piHome);
+	writeFileSync(join(piHome, "settings.json"), JSON.stringify({ packages }));
+	return piHome;
+}
+
+function fakePaths() {
+	const root = mkdtempSync(join(tmpdir(), "packed-maintenance-state-"));
+	roots.push(root);
+	return resolvePackedPaths({ env: { PI_PACKED_HOME: root } });
+}
+
+const registry: Registry = {
+	async search() {
+		return { total: 0, results: [] };
+	},
+	async searchPage() {
+		return { total: 0, results: [] };
+	},
+	async searchAll() {
+		return [];
+	},
+	async info(name) {
+		return { name, version: "1.0.0" };
+	},
+};
+
+const installer: Installer = {
+	async install(source) {
+		return `installed ${source}`;
+	},
+	async remove(source) {
+		return `removed ${source}`;
+	},
+	async update(source) {
+		return { output: `updated ${source}`, reloadRequired: false, alreadyUpToDate: true, pinned: false };
+	},
+};
+
+class RecordingDaemonServiceInstaller {
+	gotSources: string[] = [];
+	async install(
+		_piHome: string,
+		source: string,
+	): Promise<{ ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }> {
+		this.gotSources.push(source);
+		return { ok: false, reason: "not a daemon", notADaemon: true };
+	}
+	async remove(): Promise<{ ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }> {
+		return { ok: false, reason: "not a daemon", notADaemon: true };
+	}
+	async restart(): Promise<
+		{ ok: true; restarted: boolean; reason?: string; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }
+	> {
+		return { ok: false, reason: "not a daemon", notADaemon: true };
+	}
+}
+
+describe("startPackedDaemon's own maintenance-task wiring (self-heals Vehicle drift, not just per-package on demand)", () => {
+	it("includes a vehicle-reconcile task, defaulting to RECONCILE_INTERVAL_DEFAULT_MS", () => {
+		const piHome = fakePiHome([]);
+		const paths = fakePaths();
+		const options = daemonOptions({ paths, reg: registry, inst: installer, piHome, maintenanceTasks: [] });
+		// maintenanceTasks: [] is itself the override under test setup convention (see
+		// daemon-kit-migration.test.ts) for every OTHER test in this file that needs the
+		// real default list; assert its shape directly here via a second, non-overridden call.
+		expect(options.maintenanceTasks).toEqual([]);
+	});
+
+	it("the default (non-overridden) maintenance list names vehicle-reconcile at the configured interval", () => {
+		const piHome = fakePiHome([]);
+		const paths = fakePaths();
+		const installerSpy = new RecordingDaemonServiceInstaller();
+		const options = daemonOptions({ paths, reg: registry, inst: installer, piHome, daemonServiceInstaller: installerSpy });
+		const task = options.maintenanceTasks?.find((t) => t.name === "vehicle-reconcile");
+		expect(task).toBeDefined();
+		expect(task?.intervalMs).toBe(RECONCILE_INTERVAL_DEFAULT_MS);
+	});
+
+	it("vehicle-reconcile sweeps every package declared in piHome's own settings through the injected installer", async () => {
+		const piHome = fakePiHome(["npm:@danypops/probe", "npm:@danypops/other"]);
+		const paths = fakePaths();
+		const installerSpy = new RecordingDaemonServiceInstaller();
+		const options = daemonOptions({ paths, reg: registry, inst: installer, piHome, daemonServiceInstaller: installerSpy });
+		const task = options.maintenanceTasks?.find((t) => t.name === "vehicle-reconcile");
+		expect(task).toBeDefined();
+
+		// daemonOptions() also fires every default task once at startup (see the dedicated
+		// startup-self-heal test below) -- let that finish, then isolate this test's own
+		// explicit invocation from it rather than racing the two.
+		await new Promise((resolveTick) => setTimeout(resolveTick, 20));
+		installerSpy.gotSources = [];
+		await task?.run();
+
+		expect(installerSpy.gotSources).toEqual(["npm:@danypops/probe", "npm:@danypops/other"]);
+	});
+
+	it("runs vehicle-reconcile once automatically at startup, not just on its own interval -- the actual self-heal", async () => {
+		const piHome = fakePiHome(["npm:@danypops/probe"]);
+		const paths = fakePaths();
+		const installerSpy = new RecordingDaemonServiceInstaller();
+		mkdirSync(join(piHome, "npm", "node_modules"), { recursive: true });
+		daemonOptions({ paths, reg: registry, inst: installer, piHome, daemonServiceInstaller: installerSpy });
+
+		// The startup fire-and-forget is intentionally not awaited by daemonOptions itself
+		// (matching every other default maintenance task) -- give its microtasks a turn.
+		await new Promise((resolveTick) => setTimeout(resolveTick, 10));
+
+		expect(installerSpy.gotSources).toEqual(["npm:@danypops/probe"]);
+	});
+});