@danypops/pi-packed 0.27.11 → 0.27.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-packed",
-  "version": "0.27.11",
+  "version": "0.27.12",
   "description": "Pi package lifecycle, validation, daemon, tools, profiles, and TUI",
   "type": "module",
   "bin": {

package/service/src/adoption/doctor.ts

@@ -6,7 +6,7 @@
  * kind of collision at actual startup, one package at a time; doctor
  * answers the same question proactively, before pi ever runs.
  */
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { createNodeServiceInstallDeps } from "@danypops/vehicle-server/service";
 import { listPackageResources, type PackageResources, resolveInstalledDir } from "../packages/resources.ts";
@@ -134,6 +134,13 @@ export async function runDoctor(piHome: string, projectRoot?: string, options: S
 	const serviceReport = checkServiceUnitPaths(piHome, projectRoot, {
 		...createNodeServiceInstallDeps(),
 		fileExists: existsSync,
+		getMtimeMs: (path) => {
+			try {
+				return statSync(path).mtimeMs;
+			} catch {
+				return undefined;
+			}
+		},
 	});
 
 	return {

package/service/src/adoption/service-doctor.ts

@@ -1,9 +1,10 @@
+import { join } from "node:path";
 import type { ServiceInstallDeps } from "@danypops/vehicle-server/service";
 import { readInstalledPackagesAcrossScopes } from "../packages/installed.ts";
 import { resolveDaemonServiceSpec } from "../daemon/daemon-service.ts";
 
 export interface ServiceUnitDiagnostic {
-	code: "SERVICE_EXEC_PATH_MISSING" | "SERVICE_NOT_RUNNING" | "SERVICE_STATUS_UNAVAILABLE";
+	code: "SERVICE_EXEC_PATH_MISSING" | "SERVICE_NOT_RUNNING" | "SERVICE_STATUS_UNAVAILABLE" | "SERVICE_STALE_CODE";
 	severity: "error" | "warning";
 	package: string;
 	unitName: string;
@@ -18,10 +19,23 @@ export interface ServiceDoctorReport {
 
 export interface ServiceDoctorDeps extends ServiceInstallDeps {
 	fileExists(path: string): boolean;
+	/** Undefined (never throws) when the path doesn't exist or can't be stat'd. */
+	getMtimeMs(path: string): number | undefined;
 }
 
 interface ArmadaStatus {
-	vehicles?: Array<{ name?: string; executable?: string; nativeStatus?: string; ready?: boolean }>;
+	vehicles?: Array<{ name?: string; executable?: string; nativeStatus?: string; ready?: boolean; nativePid?: number }>;
+}
+
+/** A boot/registration race can leave a process's own start time a few seconds behind its package.json's write; only a gap past this is treated as a genuinely stale running daemon. */
+const STALE_CODE_GRACE_MS = 15_000;
+
+/** Undefined (never throws) when `pid` isn't a running process this host can inspect, or `ps` isn't available. */
+function processStartTimeMs(pid: number, deps: ServiceDoctorDeps): number | undefined {
+	const result = deps.runCommand("ps", ["-o", "lstart=", "-p", String(pid)]);
+	if (!result.ok) return undefined;
+	const parsed = Date.parse(result.output.trim());
+	return Number.isNaN(parsed) ? undefined : parsed;
 }
 
 export function checkServiceUnitPaths(
@@ -96,6 +110,20 @@ export function checkServiceUnitPaths(
 				unitName: managedPackage.spec.name,
 				message: `${managedPackage.spec.name}'s Armada service is ${vehicle.nativeStatus}; start it through Armada before connecting`,
 			});
+			continue;
+		}
+		if (vehicle.nativePid !== undefined) {
+			const packageJsonMtime = deps.getMtimeMs(join(piHome, "npm", "node_modules", managedPackage.packageName, "package.json"));
+			const startedAt = processStartTimeMs(vehicle.nativePid, deps);
+			if (packageJsonMtime !== undefined && startedAt !== undefined && startedAt < packageJsonMtime - STALE_CODE_GRACE_MS) {
+				diagnostics.push({
+					code: "SERVICE_STALE_CODE",
+					severity: "warning",
+					package: managedPackage.packageName,
+					unitName: managedPackage.spec.name,
+					message: `${managedPackage.spec.name}'s process (pid ${vehicle.nativePid}) started before its own package.json was last written -- it is very likely still running old in-memory code; restart it through Armada`,
+				});
+			}
 		}
 	}
 	return { ok: diagnostics.length === 0, diagnostics, checked };

package/service/test/service-doctor.test.ts

@@ -37,6 +37,7 @@ function fakeDeps(status: unknown, fileExists = true): ServiceDoctorDeps {
 	return {
 		armadaCliPath: "/armada/cli.js",
 		fileExists: () => fileExists,
+		getMtimeMs: () => undefined,
 		runCommand: () => ({ ok: true, output: JSON.stringify(status) }),
 	};
 }
@@ -125,6 +126,59 @@ describe("checkServiceUnitPaths", () => {
 		});
 	});
 
+	it("reports a running Vehicle whose process predates its own package.json as stale code, not an error", () => {
+		const home = piHome(["npm:fakedaemon"]);
+		const dir = installDaemonPackage(home, "fakedaemon");
+		const deps: ServiceDoctorDeps = {
+			armadaCliPath: "/armada/cli.js",
+			fileExists: () => true,
+			getMtimeMs: () => Date.now(),
+			runCommand: (command) =>
+				command === "ps"
+					? { ok: true, output: new Date(Date.now() - 60_000).toString() }
+					: {
+							ok: true,
+							output: JSON.stringify({
+								vehicles: [{ name: "fakedaemon", executable: join(dir, "cli.ts"), nativeStatus: "running", nativePid: 4242 }],
+							}),
+						},
+		};
+		const report = checkServiceUnitPaths(home, undefined, deps);
+		expect(report).toEqual({
+			ok: false,
+			checked: 1,
+			diagnostics: [
+				{
+					code: "SERVICE_STALE_CODE",
+					severity: "warning",
+					package: "fakedaemon",
+					unitName: "fakedaemon",
+					message: expect.stringContaining("pid 4242"),
+				},
+			],
+		});
+	});
+
+	it("never flags a running Vehicle whose process started after its own package.json was last written", () => {
+		const home = piHome(["npm:fakedaemon"]);
+		const dir = installDaemonPackage(home, "fakedaemon");
+		const deps: ServiceDoctorDeps = {
+			armadaCliPath: "/armada/cli.js",
+			fileExists: () => true,
+			getMtimeMs: () => Date.now() - 60_000,
+			runCommand: (command) =>
+				command === "ps"
+					? { ok: true, output: new Date().toString() }
+					: {
+							ok: true,
+							output: JSON.stringify({
+								vehicles: [{ name: "fakedaemon", executable: join(dir, "cli.ts"), nativeStatus: "running", nativePid: 4242 }],
+							}),
+						},
+		};
+		expect(checkServiceUnitPaths(home, undefined, deps)).toEqual({ ok: true, diagnostics: [], checked: 1 });
+	});
+
 	it("reports Armada status failure without guessing from native descriptors", () => {
 		const home = piHome(["npm:fakedaemon"]);
 		installDaemonPackage(home, "fakedaemon");