@danypops/pi-packed 0.27.3 → 0.27.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-packed",
-  "version": "0.27.3",
+  "version": "0.27.5",
   "description": "Pi package lifecycle, validation, daemon, tools, profiles, and TUI",
   "type": "module",
   "bin": {
@@ -33,7 +33,7 @@
     "@danypops/vehicle-client": "^0.10.0",
     "@danypops/vehicle-client-pi": "^0.40.1",
     "@danypops/vehicle-core": "^0.15.0",
-    "@danypops/vehicle-server": "^0.24.1",
+    "@danypops/vehicle-server": "^0.24.2",
     "jiti": "^2.7.0",
     "malevich-tui-components": "^0.21.1",
     "publint": "0.3.22",

package/service/src/daemon/daemon-service.ts

@@ -455,7 +455,13 @@ export function listManagedPackages(piHome: string, projectRoot?: string): Insta
 }
 
 export interface ReconcileAllResult {
-	reconciled: Array<{ packageName: string; vehicleName: string; installed: boolean; reason?: string }>;
+	/** `versionChanged` is true only when this pass's newly-resolved version genuinely differs
+	 * from what Armada had registered before this sweep started -- `installed: true` alone means
+	 * only "the register call itself succeeded", which is true on every healthy pass whether or
+	 * not anything actually changed underneath (register()/reconcile() is a safe no-op against
+	 * unchanged desired state). A caller wanting to know whether this pass genuinely restarted
+	 * something (vs. just re-confirmed a healthy, unchanged fleet) must check this, not `installed`. */
+	reconciled: Array<{ packageName: string; vehicleName: string; installed: boolean; versionChanged: boolean; reason?: string }>;
 	skipped: number;
 	failed: Array<{ packageName: string; reason: string }>;
 	/** Every Vehicle unregistered because this sweep no longer discovers it at all -- see pruneStaleVehicles. */
@@ -555,6 +561,13 @@ export async function reconcileAllDaemonServices(
 	const failed: ReconcileAllResult["failed"] = [];
 	const seen = new Set<string>();
 	let skipped = 0;
+	// Snapshot BEFORE this sweep's own install() calls mutate Armada's registration -- the only
+	// way to tell "this pass's register() call genuinely changed something" from "register()
+	// succeeded against an already-current registration", since install()'s own ServiceInstallResult
+	// reports only the latter.
+	const previousVersions = new Map<string, string>(
+		(await installer.listRegisteredVehicles()).map((vehicle) => [String(vehicle.name), vehicle.version]),
+	);
 	for (const pkg of packages) {
 		// Re-registering the daemon from inside its own process makes Armada stop
 		// that process before registration can start the replacement.
@@ -577,6 +590,7 @@ export async function reconcileAllDaemonServices(
 			packageName: pkg.name,
 			vehicleName: resolved.spec.name,
 			installed: resolved.result.installed,
+			versionChanged: previousVersions.get(resolved.spec.name) !== resolved.spec.version,
 			...(resolved.result.installed ? {} : { reason: resolved.result.reason }),
 		});
 	}

package/service/src/daemon/daemon.ts

@@ -127,6 +127,20 @@ export function daemonOptions(options: StartPackedDaemonOptions): StartDaemonOpt
 			intervalMs: envMs(ENV.RECONCILE_SECS, RECONCILE_INTERVAL_DEFAULT_MS),
 			run: async () => {
 				const result = await reconcileAllDaemonServices(piHome, undefined, daemonServiceInstaller);
+				// A package updated through a route pi-packed never sees at all (e.g. the generic,
+				// daemon-unaware `pi update --extension` / pkg_update path -- see
+				// pkg-update-never-restarts-vehicle-daemon) leaves this as the ONLY thing that ever
+				// notices and restarts the stale daemon. Logging only on failure made every silent
+				// success indistinguishable from "this never ran" -- there was no way to confirm a
+				// restart this task performed actually happened, short of checking the process's own
+				// PID by hand.
+				const changed = result.reconciled.filter((entry) => entry.installed && entry.versionChanged);
+				if (changed.length > 0 || result.pruned.length > 0) {
+					logger.info("vehicle-reconcile applied changes", {
+						reconciled: changed.map((entry) => entry.vehicleName),
+						pruned: result.pruned.map((entry) => entry.vehicleName),
+					});
+				}
 				if (result.failed.length > 0) {
 					logger.warn("vehicle-reconcile completed with failures", {
 						reconciled: result.reconciled.length,
@@ -171,28 +185,23 @@ export function daemonOptions(options: StartPackedDaemonOptions): StartDaemonOpt
 	};
 }
 
-function runInitialMaintenance(maintenanceTasks: MaintenanceTask[] | undefined): void {
-	for (const task of maintenanceTasks ?? []) {
-		void Promise.resolve(task.run()).catch((error) =>
-			logger.error(`maintenance task failed: ${task.name}`, { error: error instanceof Error ? error.message : String(error) }),
-		);
-	}
-}
-
+// startDaemon() itself now runs every maintenance task once immediately at startup (in
+// addition to its own interval) -- see @danypops/vehicle-server's own daemon.ts. This used to
+// be a bespoke wrapper here (runInitialMaintenance(), called after startDaemon() returned, or
+// from serveMain()'s onListen) working around a bare setInterval() never firing until its full
+// interval first elapsed; kept here would now double-run every task on every startup. Every
+// OTHER vehicle-server-based daemon (lector, jittor, papyrus, pipes, tickets,
+// web-spider-daemon) never had this workaround at all and now gets the same fix for free from
+// the shared implementation, instead of needing to independently reinvent it.
 export async function startPackedDaemon(options: StartPackedDaemonOptions = {}): Promise<RunningDaemon> {
-	const configured = daemonOptions(options);
-	const running = await startDaemon(configured);
-	runInitialMaintenance(configured.maintenanceTasks);
-	return running;
+	return startDaemon(daemonOptions(options));
 }
 
 export function serveMain(): void {
-	const configured = daemonOptions({});
 	runDaemonProcess({
-		...configured,
+		...daemonOptions({}),
 		onListen: ({ host, port }) => {
 			logger.info("listening", { host, port });
-			runInitialMaintenance(configured.maintenanceTasks);
 		},
 	});
 }

package/service/src/shared/constants.ts

@@ -52,7 +52,17 @@ export const INDEX_OPERATION_TIMEOUT_MS = 10 * 60_000;
 export const WATCH_INTERVAL_DEFAULT_MS = 30 * 60_000; // updates diff cadence
 export const CATALOG_INTERVAL_DEFAULT_MS = 6 * 3_600_000; // full mirror TTL
 export const INDEX_INTERVAL_DEFAULT_MS = 6 * 3_600_000; // static index regeneration TTL, same cadence as the catalog mirror it reads from
-export const RECONCILE_INTERVAL_DEFAULT_MS = 30 * 60_000; // Vehicle-service drift sweep cadence -- catches an out-of-band npm install/update a running daemon never picked up
+// Vehicle-service drift sweep cadence -- catches an out-of-band npm install/update a running
+// daemon never picked up (e.g. a plain `pkg_update`/`pi update --extension`, which has no way to
+// notify Armada/pi-packed at all -- see pkg-update-never-restarts-vehicle-daemon). Now that
+// startDaemon() also runs every maintenance task once immediately at startup (see
+// vehicle-server's own daemon.ts), a restart of pi-packed itself no longer waits out this
+// interval at all -- this cadence now only bounds the OTHER case: an out-of-band update that
+// lands while pi-packed's own daemon is already running and stays up. 30 minutes was tuned for
+// a background safety net, not an interactive "I just updated something" workflow; 5 minutes
+// keeps the same self-healing guarantee at a much more reasonable latency for a per-pass cost
+// that's still just a handful of cheap native-service inspections for a fleet this size.
+export const RECONCILE_INTERVAL_DEFAULT_MS = 5 * 60_000;
 export const IDLE_BUDGET_DEFAULT_MS = 10 * 60_000; // on-demand self-exit
 export const WATCHDOG_TICK_MS = 15_000;
 

package/service/test/cli.test.ts

@@ -120,7 +120,7 @@ class FakeDaemonServiceInstaller {
 		return {
 			ok: true,
 			output: "reconciled 1 Vehicle(s), skipped 0 non-daemon package(s)",
-			reconciled: [{ packageName: "@danypops/probe", vehicleName: "probe", installed: true }],
+			reconciled: [{ packageName: "@danypops/probe", vehicleName: "probe", installed: true, versionChanged: true }],
 			skipped: 0,
 			failed: [],
 			pruned: [],
@@ -604,7 +604,7 @@ describe("CLI", () => {
 		expect(JSON.parse(json.out)).toEqual({
 			ok: true,
 			output: "reconciled 1 Vehicle(s), skipped 0 non-daemon package(s)",
-			reconciled: [{ packageName: "@danypops/probe", vehicleName: "probe", installed: true }],
+			reconciled: [{ packageName: "@danypops/probe", vehicleName: "probe", installed: true, versionChanged: true }],
 			skipped: 0,
 			failed: [],
 			pruned: [],

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

@@ -226,6 +226,33 @@ describe("startPackedDaemon's own maintenance-task wiring (self-heals Vehicle dr
 		}
 	});
 
+	/**
+	 * Regression guard for the double-execution risk this file's own daemon.ts (startPackedDaemon/
+	 * serveMain) used to carry: a bespoke runInitialMaintenance() wrapper called explicitly, on top
+	 * of what startDaemon() (vehicle-server) itself now already does since it started running every
+	 * maintenance task once immediately at startup. Removed entirely -- this proves it stayed
+	 * removed, not just that a task runs at least once (the test above already covers that).
+	 */
+	it("runs each maintenance task exactly once at startup, never twice", async () => {
+		const piHome = fakePiHome([]);
+		const paths = fakePaths();
+		let runs = 0;
+		const task: MaintenanceTask = {
+			name: "probe-exactly-once",
+			intervalMs: RECONCILE_INTERVAL_DEFAULT_MS,
+			run: () => {
+				runs++;
+			},
+		};
+		const running = await startPackedDaemon({ paths, reg: registry, inst: installer, piHome, maintenanceTasks: [task] });
+		try {
+			await new Promise((resolve) => setTimeout(resolve, 30));
+			expect(runs).toBe(1);
+		} finally {
+			await running.stop();
+		}
+	});
+
 	it("does not reconcile Armada before the daemon has published its readiness handle", async () => {
 		const piHome = fakePiHome(["npm:@danypops/pi-packed", "npm:@danypops/probe"]);
 		const paths = fakePaths();
@@ -316,6 +343,46 @@ describe("startPackedDaemon's own maintenance-task wiring (self-heals Vehicle dr
 		});
 	});
 
+	/**
+	 * Real gap this closes: install()'s own ServiceInstallResult reports `installed: true`
+	 * whenever register()/reconcile() SUCCEEDS -- which is true on every healthy pass whether or
+	 * not anything actually changed underneath (register() is a safe no-op against unchanged
+	 * desired state). A caller logging "applied changes" off `installed` alone would say so on
+	 * literally every tick of a healthy, unchanged fleet -- see pkg-update-never-restarts-
+	 * vehicle-daemon. versionChanged is the honest signal instead.
+	 */
+	describe("reconcileAllDaemonServices reports versionChanged honestly, not just installed", () => {
+		it("is true on a package's first-ever registration, false on an unchanged re-sweep, true again once its on-disk version actually moves", async () => {
+			const piHome = fakePiHome(["npm:@danypops/probe"]);
+			installMockDaemon(piHome, "@danypops/probe");
+			const harness = await createArmadaTestHarness();
+			try {
+				const installer = new RealDaemonServiceInstaller(harness.registrar);
+
+				const first = await reconcileAllDaemonServices(piHome, undefined, installer);
+				expect(first.reconciled).toEqual([
+					{ packageName: "@danypops/probe", vehicleName: "probe", installed: true, versionChanged: true },
+				]);
+
+				const second = await reconcileAllDaemonServices(piHome, undefined, installer);
+				expect(second.reconciled).toEqual([
+					{ packageName: "@danypops/probe", vehicleName: "probe", installed: true, versionChanged: false },
+				]);
+
+				writeFileSync(
+					join(piHome, "npm", "node_modules", "@danypops", "probe", "package.json"),
+					JSON.stringify({ name: "@danypops/probe", version: "1.1.0", packed: { daemonService: { binPath: "cli.ts", args: ["serve"] } } }),
+				);
+				const third = await reconcileAllDaemonServices(piHome, undefined, installer);
+				expect(third.reconciled).toEqual([
+					{ packageName: "@danypops/probe", vehicleName: "probe", installed: true, versionChanged: true },
+				]);
+			} finally {
+				await harness.dispose();
+			}
+		});
+	});
+
 	describe("reconcileAllDaemonServices pruning (the-armada-registrar-jittor-web-spider-daemon-collision)", () => {
 		function stalePiHomeVehicle(piHome: string, name: string): VehicleSpec {
 			return {