@danypops/pi-packed 0.21.1 → 0.21.2

package/package.json

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

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

@@ -3,7 +3,7 @@ import { readInstalledPackagesAcrossScopes } from "../packages/installed.ts";
 import { resolveDaemonServiceSpec } from "../daemon/daemon-service.ts";
 
 export interface ServiceUnitDiagnostic {
-	code: "SERVICE_EXEC_PATH_MISSING" | "SERVICE_STATUS_UNAVAILABLE";
+	code: "SERVICE_EXEC_PATH_MISSING" | "SERVICE_NOT_RUNNING" | "SERVICE_STATUS_UNAVAILABLE";
 	severity: "error" | "warning";
 	package: string;
 	unitName: string;
@@ -21,7 +21,7 @@ export interface ServiceDoctorDeps extends ServiceInstallDeps {
 }
 
 interface ArmadaStatus {
-	vehicles?: Array<{ name?: string; executable?: string }>;
+	vehicles?: Array<{ name?: string; executable?: string; nativeStatus?: string; ready?: boolean }>;
 }
 
 export function checkServiceUnitPaths(
@@ -79,14 +79,24 @@ export function checkServiceUnitPaths(
 		if (!vehicle) continue;
 		checked++;
 		const executable = vehicle.executable ?? managedPackage.spec.binPath;
-		if (deps.fileExists(executable)) continue;
-		diagnostics.push({
-			code: "SERVICE_EXEC_PATH_MISSING",
-			severity: "error",
-			package: managedPackage.packageName,
-			unitName: managedPackage.spec.name,
-			message: `${managedPackage.spec.name}'s Armada declaration references a path that no longer exists: ${executable}`,
-		});
+		if (!deps.fileExists(executable)) {
+			diagnostics.push({
+				code: "SERVICE_EXEC_PATH_MISSING",
+				severity: "error",
+				package: managedPackage.packageName,
+				unitName: managedPackage.spec.name,
+				message: `${managedPackage.spec.name}'s Armada declaration references a path that no longer exists: ${executable}`,
+			});
+		}
+		if (vehicle.nativeStatus !== undefined && vehicle.nativeStatus !== "running") {
+			diagnostics.push({
+				code: "SERVICE_NOT_RUNNING",
+				severity: "error",
+				package: managedPackage.packageName,
+				unitName: managedPackage.spec.name,
+				message: `${managedPackage.spec.name}'s Armada service is ${vehicle.nativeStatus}; start it through Armada before connecting`,
+			});
+		}
 	}
 	return { ok: diagnostics.length === 0, diagnostics, checked };
 }

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

@@ -226,6 +226,9 @@ export interface ReconcileAllResult {
 
 /** Matches readPackageDeclarations' own bound -- a reconcile-all sweep never processes an unbounded package list. */
 const MAX_RECONCILE_PACKAGES = 500;
+const PACKED_PACKAGE_NAME = "@danypops/pi-packed";
+const PACKED_VEHICLE_NAME = "pi-packed";
+const SELF_REGISTRATION_REASON = "Packed cannot replace its own Armada service from inside the running daemon";
 
 /**
  * Sweeps every installed Packed package (global scope, plus a project's own
@@ -253,6 +256,12 @@ export async function reconcileAllDaemonServices(
 	const seen = new Set<string>();
 	let skipped = 0;
 	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.
+		if (pkg.name === PACKED_PACKAGE_NAME) {
+			skipped++;
+			continue;
+		}
 		const resolved = await installer.install(piHome, `npm:${pkg.name}`);
 		if (!resolved.ok) {
 			if (resolved.notADaemon) {
@@ -305,6 +314,9 @@ export class RealDaemonServiceInstaller implements DaemonServiceInstaller {
 	): Promise<{ ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }> {
 		const resolved = resolveDaemonServiceSpec(piHome, source);
 		if (!resolved.ok) return resolved;
+		if (resolved.spec.name === PACKED_VEHICLE_NAME) {
+			return { ok: true, result: { installed: false, reason: SELF_REGISTRATION_REASON }, spec: resolved.spec };
+		}
 		const result = await registerVehicleService(resolved.spec, this.registrar);
 		return { ok: true, result, spec: resolved.spec };
 	}
@@ -315,6 +327,9 @@ export class RealDaemonServiceInstaller implements DaemonServiceInstaller {
 	): Promise<{ ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }> {
 		const resolved = resolveDaemonServiceSpec(piHome, source);
 		if (!resolved.ok) return resolved;
+		if (resolved.spec.name === PACKED_VEHICLE_NAME) {
+			return { ok: true, result: { installed: false, reason: SELF_REGISTRATION_REASON }, spec: resolved.spec };
+		}
 		const result = await unregisterVehicleService(resolved.spec.name, this.registrar);
 		return { ok: true, result, spec: resolved.spec };
 	}
@@ -325,6 +340,9 @@ export class RealDaemonServiceInstaller implements DaemonServiceInstaller {
 	): Promise<{ ok: true; restarted: boolean; reason?: string; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }> {
 		const resolved = resolveDaemonServiceSpec(piHome, source);
 		if (!resolved.ok) return resolved;
+		if (resolved.spec.name === PACKED_VEHICLE_NAME) {
+			return { ok: true, restarted: false, reason: SELF_REGISTRATION_REASON, spec: resolved.spec };
+		}
 		if (!(await isVehicleServiceRegistered(resolved.spec.name, this.registrar))) {
 			return { ok: true, restarted: false, reason: `no persistent service is registered for ${resolved.spec.name}`, spec: resolved.spec };
 		}

package/service/src/daemon/daemon.ts

@@ -102,6 +102,9 @@ export function daemonOptions(options: StartPackedDaemonOptions): StartDaemonOpt
 
 	if (options.maintenanceTasks === undefined) {
 		for (const task of maintenanceTasks) {
+			// Armada reconciles the whole desired fleet. Running this before Packed
+			// publishes its readiness handle makes Armada replace Packed mid-startup.
+			if (task.name === "vehicle-reconcile") continue;
 			void Promise.resolve(task.run()).catch((error) =>
 				logger.error(`maintenance task failed: ${task.name}`, { error: error instanceof Error ? error.message : String(error) }),
 			);
@@ -120,13 +123,28 @@ export function daemonOptions(options: StartPackedDaemonOptions): StartDaemonOpt
 	};
 }
 
-export function startPackedDaemon(options: StartPackedDaemonOptions = {}): Promise<RunningDaemon> {
-	return startDaemon(daemonOptions(options));
+function runReadyVehicleReconcile(maintenanceTasks: MaintenanceTask[] | undefined): void {
+	const task = maintenanceTasks?.find((candidate) => candidate.name === "vehicle-reconcile");
+	if (!task) return;
+	void Promise.resolve(task.run()).catch((error) =>
+		logger.error(`maintenance task failed: ${task.name}`, { error: error instanceof Error ? error.message : String(error) }),
+	);
+}
+
+export async function startPackedDaemon(options: StartPackedDaemonOptions = {}): Promise<RunningDaemon> {
+	const configured = daemonOptions(options);
+	const running = await startDaemon(configured);
+	runReadyVehicleReconcile(configured.maintenanceTasks);
+	return running;
 }
 
 export function serveMain(): void {
+	const configured = daemonOptions({});
 	runDaemonProcess({
-		...daemonOptions({}),
-		onListen: ({ host, port }) => logger.info("listening", { host, port }),
+		...configured,
+		onListen: ({ host, port }) => {
+			logger.info("listening", { host, port });
+			runReadyVehicleReconcile(configured.maintenanceTasks);
+		},
 	});
 }

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

@@ -1,9 +1,9 @@
 import { afterEach, describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, 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 { daemonOptions, startPackedDaemon } 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";
@@ -111,17 +111,30 @@ describe("startPackedDaemon's own maintenance-task wiring (self-heals Vehicle dr
 		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"]);
+	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();
 		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.
+		// Give pre-listen maintenance enough time to expose an accidental Armada call.
 		await new Promise((resolveTick) => setTimeout(resolveTick, 10));
 
-		expect(installerSpy.gotSources).toEqual(["npm:@danypops/probe"]);
+		expect(installerSpy.gotSources).toEqual([]);
+	});
+
+	it("reconciles Armada only after the real daemon handle is ready", async () => {
+		const piHome = fakePiHome(["npm:@danypops/pi-packed", "npm:@danypops/probe"]);
+		const paths = fakePaths();
+		const installerSpy = new RecordingDaemonServiceInstaller();
+		const running = await startPackedDaemon({ paths, reg: registry, inst: installer, piHome, daemonServiceInstaller: installerSpy });
+		try {
+			await new Promise((resolveTick) => setTimeout(resolveTick, 10));
+			expect(existsSync(paths.handle)).toBe(true);
+			expect(installerSpy.gotSources).toEqual(["npm:@danypops/probe"]);
+		} finally {
+			await running.stop();
+		}
 	});
 });

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

@@ -229,6 +229,18 @@ describe("RealDaemonServiceInstaller -- Armada registration through the in-proce
 		expect(registrar.registered.has("web-spider-daemon")).toBe(true);
 	});
 
+	it("install() never asks Armada to replace Packed from inside Packed's own process", async () => {
+		const piHome = fakePiHome();
+		writePackage(piHome, "@danypops/pi-packed", { binPath: "service/src/cli/cli.ts", args: ["serve"] });
+		const registrar = new FakeVehicleRegistrar();
+		const installer = new RealDaemonServiceInstaller(registrar);
+
+		const outcome = await installer.install(piHome, "npm:@danypops/pi-packed");
+
+		expect(outcome).toMatchObject({ ok: true, result: { installed: false }, spec: { name: "pi-packed" } });
+		expect(registrar.registered.size).toBe(0);
+	});
+
 	it("install() reports a non-daemon package without ever touching the registrar", async () => {
 		const piHome = fakePiHome();
 		writePackage(piHome, "some-pkg", undefined);

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

@@ -64,6 +64,29 @@ describe("checkServiceUnitPaths", () => {
 		expect(report).toEqual({ ok: true, diagnostics: [], checked: 1 });
 	});
 
+	it("reports an Armada-managed Vehicle that is declared but not running", () => {
+		const home = piHome(["npm:fakedaemon"]);
+		const dir = installDaemonPackage(home, "fakedaemon");
+		const report = checkServiceUnitPaths(
+			home,
+			undefined,
+			fakeDeps({ vehicles: [{ name: "fakedaemon", executable: join(dir, "cli.ts"), nativeStatus: "stopped", ready: false }], diagnostics: [] }),
+		);
+		expect(report).toEqual({
+			ok: false,
+			checked: 1,
+			diagnostics: [
+				{
+					code: "SERVICE_NOT_RUNNING",
+					severity: "error",
+					package: "fakedaemon",
+					unitName: "fakedaemon",
+					message: expect.stringContaining("stopped"),
+				},
+			],
+		});
+	});
+
 	it("reports a missing Armada-managed executable", () => {
 		const home = piHome(["npm:fakedaemon"]);
 		const dir = installDaemonPackage(home, "fakedaemon");