@danypops/pi-packed 0.27.3 → 0.27.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-packed",
-  "version": "0.27.3",
+  "version": "0.27.4",
   "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.ts

@@ -127,6 +127,19 @@ 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.
+				if (result.reconciled.some((entry) => entry.installed) || result.pruned.length > 0) {
+					logger.info("vehicle-reconcile applied changes", {
+						reconciled: result.reconciled.filter((entry) => entry.installed).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 +184,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/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();