@danypops/pi-packed 0.23.0 → 0.25.0

package/extension/src/vehicle-tools.ts

@@ -74,11 +74,10 @@ export async function registerPackedVehicle(pi: ExtensionAPI): Promise<void> {
 		await registerVehicleTools(pi, client, {
 			permissions: ["packed:read"],
 			principal: { id: "pi-packed" },
-			// ownVehicleName must match daemon.ts's own PACKED_VEHICLE_NAME (the shared Vehicle Handle
-			// Directory entry Packed's own daemon registers under via daemonOptions()'s vehicleName --
-			// see service/src/daemon/daemon.ts). activateForeignOperation is auto-supplied by
-			// registerVehicleTools. See enable-vehicle-shell-broker-mode-in-pi-packed.
-			shell: { coreOperations: CORE_OPERATIONS, broker: { ownVehicleName: "pi-packed" } },
+			// tools_list/tools_man are a neutral, process-wide singleton now (vehicle-client-pi's own
+			// ensureVehicleShellHandle) -- no ownVehicleName/broker option needed here anymore; every
+			// vehicle in the process (including packed's own) is discovered and namespaced uniformly.
+			shell: { coreOperations: CORE_OPERATIONS },
 		});
 	} catch {
 		// Daemon state is stale/unreachable -- degrade silently, matching

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-packed",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "Pi package lifecycle, validation, daemon, tools, profiles, and TUI",
   "type": "module",
   "bin": {
@@ -27,11 +27,11 @@
     "typecheck": "bunx tsc --noEmit"
   },
   "dependencies": {
-    "@danypops/armada": "^0.4.3",
+    "@danypops/armada": "^0.4.6",
     "@danypops/packed": "^0.7.0",
     "@danypops/pi-extension-harness": "^0.7.0",
     "@danypops/vehicle-client": "^0.8.1",
-    "@danypops/vehicle-client-pi": "^0.39.0",
+    "@danypops/vehicle-client-pi": "^0.40.1",
     "@danypops/vehicle-core": "^0.15.0",
     "@danypops/vehicle-server": "^0.22.0",
     "jiti": "^2.7.0",

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

@@ -27,7 +27,7 @@
  */
 import { readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { createVehicleRegistrar, type VehicleRegistrar } from "@danypops/armada";
+import { createVehicleRegistrar, type VehicleRegistrar, type VehicleRegistrationOutcome, type VehicleSpec } from "@danypops/armada";
 import { resolveDaemonPaths } from "@danypops/vehicle-server/paths";
 import {
 	isVehicleServiceRegistered,
@@ -408,6 +408,15 @@ export interface ReconcileAllResult {
 	reconciled: Array<{ packageName: string; vehicleName: string; installed: boolean; reason?: string }>;
 	skipped: number;
 	failed: Array<{ packageName: string; reason: string }>;
+	/**
+	 * Every Vehicle unregistered because this same sweep could no longer
+	 * discover it by any path (neither a configured extension's own
+	 * dependency walk nor listUnconfiguredDaemonDependencies' root-pinned
+	 * scan) -- see pruneStaleVehicles' own doc comment for why this is safe
+	 * to do unconditionally rather than requiring a separate opt-in call.
+	 */
+	pruned: Array<{ vehicleName: string; executable: string }>;
+	pruneFailed: Array<{ vehicleName: string; reason: string }>;
 }
 
 /** Matches readPackageDeclarations' own bound -- a reconcile-all sweep never processes an unbounded package list. */
@@ -438,7 +447,7 @@ const SELF_REGISTRATION_REASON = "Packed cannot replace its own Armada service f
 export async function reconcileAllDaemonServices(
 	piHome: string,
 	projectRoot: string | undefined,
-	installer: Pick<DaemonServiceInstaller, "install">,
+	installer: Pick<DaemonServiceInstaller, "install" | "listRegisteredVehicles" | "unregisterVehicleByName">,
 ): Promise<ReconcileAllResult> {
 	const packages = readInstalledPackagesAcrossScopes(piHome, projectRoot).slice(0, MAX_RECONCILE_PACKAGES);
 	const reconciled: ReconcileAllResult["reconciled"] = [];
@@ -470,7 +479,62 @@ export async function reconcileAllDaemonServices(
 			...(resolved.result.installed ? {} : { reason: resolved.result.reason }),
 		});
 	}
-	return { reconciled, skipped, failed };
+	// listUnconfiguredDaemonDependencies deliberately walks the FULL top-level
+	// node_modules sweep, not just readInstalledPackagesAcrossScopes' own
+	// pi:-configured list above -- a root-pinned dependency (e.g. lector,
+	// pinned directly in piHome/npm/package.json ahead of whatever version its
+	// own pi-lector wrapper's tree would resolve) is a real, currently-running
+	// Vehicle that the configured-packages loop above never reaches at all.
+	// Folding it in here is what makes the discovered set below actually
+	// complete -- pruning against anything narrower would delete a Vehicle
+	// that's still genuinely there, just reachable by a different path.
+	for (const dep of listUnconfiguredDaemonDependencies(piHome)) seen.add(dep.vehicleName);
+	const { pruned, pruneFailed } = await pruneStaleVehicles(piHome, seen, installer);
+	return { reconciled, skipped, failed, pruned, pruneFailed };
+}
+
+/**
+ * Unregisters every Vehicle Armada currently declares that `discovered`
+ * (this same sweep's own complete union of configured-extension and
+ * root-pinned resolution) no longer produces at all -- the other half of
+ * what makes Armada authoritative for every Vehicle Packed knows about.
+ * Without this, a Vehicle whose packed.daemonService.name changed (or that
+ * a stale nested dependency copy once resolved under a different name --
+ * see this session's own live incident, a duplicate "web-spider-daemon"
+ * losing every restart's single-instance-lock race against the correctly-
+ * named "web-spider" Vehicle) just sits in the manifest forever: nothing
+ * ever re-discovers it to overwrite it, and nothing ever notices it's gone
+ * stale either.
+ *
+ * Scoped to only ever touch a Vehicle whose own `executable` lives under
+ * piHome's own npm/node_modules -- i.e. one only Packed itself could
+ * plausibly have registered in the first place. A Vehicle registered by an
+ * entirely different mechanism (a hand-rolled `armada upsert` pointing
+ * somewhere else on disk) is never a candidate, no matter how the
+ * discovered set above turns out -- this function has no way to know that
+ * caller's own intent, so it stays out of its way entirely. Packed's own
+ * Vehicle (PACKED_VEHICLE_NAME) is excluded for the same reason
+ * install()/remove()/restart() already refuse to touch it: reconcile runs
+ * from inside Packed's own process.
+ */
+async function pruneStaleVehicles(
+	piHome: string,
+	discovered: ReadonlySet<string>,
+	installer: Pick<DaemonServiceInstaller, "listRegisteredVehicles" | "unregisterVehicleByName">,
+): Promise<Pick<ReconcileAllResult, "pruned" | "pruneFailed">> {
+	const managedRoot = join(piHome, "npm", "node_modules") + "/";
+	const pruned: ReconcileAllResult["pruned"] = [];
+	const pruneFailed: ReconcileAllResult["pruneFailed"] = [];
+	const registered = await installer.listRegisteredVehicles();
+	for (const vehicle of registered) {
+		if (vehicle.name === PACKED_VEHICLE_NAME) continue;
+		if (discovered.has(vehicle.name)) continue;
+		if (!vehicle.executable.startsWith(managedRoot)) continue;
+		const outcome = await installer.unregisterVehicleByName(vehicle.name);
+		if (outcome.ok) pruned.push({ vehicleName: vehicle.name, executable: vehicle.executable });
+		else pruneFailed.push({ vehicleName: vehicle.name, reason: outcome.diagnostics.map((d) => d.message).join("; ") || "unregister failed" });
+	}
+	return { pruned, pruneFailed };
 }
 
 export interface DaemonServiceInstaller {
@@ -486,6 +550,15 @@ export interface DaemonServiceInstaller {
 		piHome: string,
 		source: string,
 	): Promise<{ ok: true; restarted: boolean; reason?: string; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }>;
+	/** Every Vehicle Armada currently declares -- see pruneStaleVehicles' own doc comment for why this exists. */
+	listRegisteredVehicles(): Promise<readonly VehicleSpec[]>;
+	/**
+	 * Unregisters by Armada vehicle NAME directly, distinct from remove()'s
+	 * own by-npm-source resolution -- pruning has no installed package left to
+	 * resolve a source from; the whole point is the vehicle survived past
+	 * whatever used to produce it.
+	 */
+	unregisterVehicleByName(name: string): Promise<VehicleRegistrationOutcome>;
 }
 
 /**
@@ -498,6 +571,14 @@ export interface DaemonServiceInstaller {
 export class RealDaemonServiceInstaller implements DaemonServiceInstaller {
 	constructor(private readonly registrar: VehicleRegistrar = createVehicleRegistrar()) {}
 
+	async listRegisteredVehicles(): Promise<readonly VehicleSpec[]> {
+		return this.registrar.listRegistered();
+	}
+
+	async unregisterVehicleByName(name: string): Promise<VehicleRegistrationOutcome> {
+		return this.registrar.unregister(name);
+	}
+
 	async install(
 		piHome: string,
 		source: string,

package/service/test/cli.test.ts

@@ -123,6 +123,8 @@ class FakeDaemonServiceInstaller {
 			reconciled: [{ packageName: "@danypops/probe", vehicleName: "probe", installed: true }],
 			skipped: 0,
 			failed: [],
+			pruned: [],
+			pruneFailed: [],
 		};
 	}
 }
@@ -605,6 +607,8 @@ describe("CLI", () => {
 			reconciled: [{ packageName: "@danypops/probe", vehicleName: "probe", installed: true }],
 			skipped: 0,
 			failed: [],
+			pruned: [],
+			pruneFailed: [],
 		});
 	});
 
@@ -1007,7 +1011,15 @@ describe("CLI", () => {
 			},
 			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: [] };
+				return {
+					ok: true,
+					output: "reconciled 0 Vehicle(s), skipped 0 non-daemon package(s)",
+					reconciled: [],
+					skipped: 0,
+					failed: [],
+					pruned: [],
+					pruneFailed: [],
+				};
 			},
 			async update(source) {
 				return { output: source, reloadRequired: false, alreadyUpToDate: true, pinned: false };
@@ -1303,6 +1315,12 @@ describe("daemon client", () => {
 						spec: { name: "pi-lsp", version: "1.0.0", binPath: "/opt/pi-lsp/cli.js", handlePath: "/tmp/pi-lsp.handle.json" },
 					};
 				},
+				async listRegisteredVehicles() {
+					return [];
+				},
+				async unregisterVehicleByName() {
+					return { ok: true, manifestHash: "hash" as never, applied: [], diagnostics: [] };
+				},
 			},
 			token: daemonToken,
 			stateDir: daemonDir,

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

@@ -2,6 +2,7 @@ import { afterEach, describe, expect, it } from "bun:test";
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import type { VehicleRegistrationOutcome, VehicleSpec } from "@danypops/armada";
 import { createArmadaTestHarness } from "@danypops/armada/testing";
 import type { MaintenanceTask } from "@danypops/vehicle-server/daemon";
 import type { ServiceInstallResult, ServiceSpec } from "@danypops/vehicle-server/service";
@@ -121,6 +122,12 @@ class RecordingDaemonServiceInstaller {
 	> {
 		return { ok: false, reason: "not a daemon", notADaemon: true };
 	}
+	async listRegisteredVehicles(): Promise<readonly VehicleSpec[]> {
+		return [];
+	}
+	async unregisterVehicleByName(): Promise<VehicleRegistrationOutcome> {
+		return { ok: true, manifestHash: "hash" as never, applied: [], diagnostics: [] };
+	}
 }
 
 describe("startPackedDaemon's own maintenance-task wiring (self-heals Vehicle drift, not just per-package on demand)", () => {
@@ -308,4 +315,171 @@ describe("startPackedDaemon's own maintenance-task wiring (self-heals Vehicle dr
 			expect(snapshot?.updates.map((u) => u.name)).toContain("@danypops/probe-daemon");
 		});
 	});
+
+	describe("reconcileAllDaemonServices pruning -- unregisters a Vehicle no longer discoverable by any path (the-armada-registrar-jittor-web-spider-daemon-collision)", () => {
+		function stalePiHomeVehicle(piHome: string, name: string): VehicleSpec {
+			return {
+				name: name as VehicleSpec["name"],
+				version: "0.1.0",
+				executable: join(piHome, "npm", "node_modules", "@danypops", "old-package", "cli.ts"),
+				arguments: ["serve"],
+				handlePath: join(piHome, "stale-handle.json"),
+				restart: { policy: "never" },
+				readiness: { timeoutMs: 500, pollIntervalMs: 50 },
+			};
+		}
+
+		it("prunes a Vehicle whose executable lives under piHome's own node_modules once nothing discovers it anymore", async () => {
+			const piHome = fakePiHome([]); // deliberately empty -- old-package no longer configured or on disk
+			const harness = await createArmadaTestHarness();
+			try {
+				await harness.registrar.register(stalePiHomeVehicle(piHome, "old-package"));
+				expect(await harness.registrar.isRegistered("old-package")).toBe(true);
+
+				const installer = new RealDaemonServiceInstaller(harness.registrar);
+				const result = await reconcileAllDaemonServices(piHome, undefined, installer);
+
+				expect(result.pruned).toEqual([{ vehicleName: "old-package", executable: stalePiHomeVehicle(piHome, "old-package").executable }]);
+				expect(result.pruneFailed).toEqual([]);
+				expect(await harness.registrar.isRegistered("old-package")).toBe(false);
+			} finally {
+				await harness.dispose();
+			}
+		});
+
+		it("never prunes a Vehicle registered outside piHome's own node_modules, regardless of discovery", async () => {
+			const piHome = fakePiHome([]);
+			const harness = await createArmadaTestHarness();
+			try {
+				await harness.registrar.register({
+					name: "externally-managed" as VehicleSpec["name"],
+					version: "1.0.0",
+					executable: "/opt/custom/cli.js",
+					arguments: ["serve"],
+					handlePath: join(piHome, "external-handle.json"),
+					restart: { policy: "never" },
+					readiness: { timeoutMs: 500, pollIntervalMs: 50 },
+				});
+
+				const installer = new RealDaemonServiceInstaller(harness.registrar);
+				const result = await reconcileAllDaemonServices(piHome, undefined, installer);
+
+				expect(result.pruned).toEqual([]);
+				expect(await harness.registrar.isRegistered("externally-managed")).toBe(true);
+			} finally {
+				await harness.dispose();
+			}
+		});
+
+		it("never prunes a Vehicle still discoverable through the configured-extension sweep -- only updates it", async () => {
+			const piHome = fakePiHome(["npm:@danypops/probe"]);
+			installMockDaemon(piHome, "@danypops/probe");
+			const harness = await createArmadaTestHarness();
+			try {
+				const installer = new RealDaemonServiceInstaller(harness.registrar);
+				const result = await reconcileAllDaemonServices(piHome, undefined, installer);
+
+				expect(result.pruned).toEqual([]);
+				expect(await harness.registrar.isRegistered("probe")).toBe(true);
+			} finally {
+				await harness.dispose();
+			}
+		});
+
+		it("never prunes a Vehicle still discoverable only through the unconfigured-daemon-dependency sweep (e.g. a root-pinned package like lector)", async () => {
+			const piHome = fakePiHome([]); // deliberately NOT settings.json-configured
+			installUnconfiguredDaemonDependency(piHome, "@danypops/probe-daemon", "1.0.0");
+			const harness = await createArmadaTestHarness();
+			try {
+				await harness.registrar.register({
+					name: "probe-daemon" as VehicleSpec["name"],
+					version: "1.0.0",
+					executable: join(piHome, "npm", "node_modules", "@danypops", "probe-daemon", "cli.ts"),
+					arguments: ["serve"],
+					handlePath: join(piHome, "probe-daemon-handle.json"),
+					restart: { policy: "never" },
+					readiness: { timeoutMs: 500, pollIntervalMs: 50 },
+				});
+
+				const installer = new RealDaemonServiceInstaller(harness.registrar);
+				const result = await reconcileAllDaemonServices(piHome, undefined, installer);
+
+				expect(result.pruned).toEqual([]);
+				expect(await harness.registrar.isRegistered("probe-daemon")).toBe(true);
+			} finally {
+				await harness.dispose();
+			}
+		});
+
+		it("never prunes pi-packed's own Vehicle, even though reconcileAllDaemonServices always skips scanning its own package", async () => {
+			const piHome = fakePiHome([]);
+			const harness = await createArmadaTestHarness();
+			try {
+				await harness.registrar.register({
+					name: "pi-packed" as VehicleSpec["name"],
+					version: "1.0.0",
+					executable: join(piHome, "npm", "node_modules", "@danypops", "pi-packed", "service", "src", "cli", "cli.ts"),
+					arguments: ["serve"],
+					handlePath: join(piHome, "pi-packed-handle.json"),
+					restart: { policy: "never" },
+					readiness: { timeoutMs: 500, pollIntervalMs: 50 },
+				});
+
+				const installer = new RealDaemonServiceInstaller(harness.registrar);
+				const result = await reconcileAllDaemonServices(piHome, undefined, installer);
+
+				expect(result.pruned).toEqual([]);
+				expect(await harness.registrar.isRegistered("pi-packed")).toBe(true);
+			} finally {
+				await harness.dispose();
+			}
+		});
+
+		it("reproduces the real web-spider/web-spider-daemon collision: the orphaned duplicate is pruned, the correctly-discovered one survives", async () => {
+			const piHome = fakePiHome(["npm:@danypops/pi-web-spider"]);
+			// pi-web-spider's own dependency-walk discovers @danypops/web-spider-daemon,
+			// whose packed.daemonService.name overrides the vehicle name to "web-spider".
+			const piWebSpiderDir = join(piHome, "npm", "node_modules", "@danypops", "pi-web-spider");
+			mkdirSync(piWebSpiderDir, { recursive: true });
+			writeFileSync(
+				join(piWebSpiderDir, "package.json"),
+				JSON.stringify({ name: "@danypops/pi-web-spider", version: "1.0.0", dependencies: { "@danypops/web-spider-daemon": "^1.0.0" } }),
+			);
+			const daemonDir = join(piHome, "npm", "node_modules", "@danypops", "web-spider-daemon");
+			mkdirSync(daemonDir, { recursive: true });
+			writeFileSync(
+				join(daemonDir, "package.json"),
+				JSON.stringify({
+					name: "@danypops/web-spider-daemon",
+					version: "1.0.0",
+					packed: { daemonService: { name: "web-spider", binPath: "cli.ts", args: ["serve"] } },
+				}),
+			);
+			writeFileSync(join(daemonDir, "cli.ts"), "// Mock Vehicle entry point.\n");
+
+			const harness = await createArmadaTestHarness();
+			try {
+				// A leftover registration from before the packed.daemonService.name override existed --
+				// the exact orphan a prior Packed version would have produced and never cleaned up.
+				await harness.registrar.register({
+					name: "web-spider-daemon" as VehicleSpec["name"],
+					version: "0.9.0",
+					executable: join(daemonDir, "cli.ts"),
+					arguments: ["serve"],
+					handlePath: join(piHome, "web-spider-daemon-handle.json"),
+					restart: { policy: "never" },
+					readiness: { timeoutMs: 500, pollIntervalMs: 50 },
+				});
+
+				const installer = new RealDaemonServiceInstaller(harness.registrar);
+				const result = await reconcileAllDaemonServices(piHome, undefined, installer);
+
+				expect(result.pruned).toEqual([{ vehicleName: "web-spider-daemon", executable: join(daemonDir, "cli.ts") }]);
+				expect(await harness.registrar.isRegistered("web-spider-daemon")).toBe(false);
+				expect(await harness.registrar.isRegistered("web-spider")).toBe(true);
+			} finally {
+				await harness.dispose();
+			}
+		});
+	});
 });

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

@@ -500,6 +500,7 @@ describe("RealDaemonServiceInstaller -- Armada registration through the in-proce
 			register: async () => ({ ok: false, diagnostics: [{ code: "X", severity: "error", path: "/", message: "native failure" }] }),
 			unregister: async () => ({ ok: false, diagnostics: [] }),
 			isRegistered: async () => false,
+			listRegistered: async () => [],
 		};
 		const installer = new RealDaemonServiceInstaller(registrar);
 

package/service/test/service.test.ts

@@ -2,6 +2,7 @@ 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 { VehicleRegistrationOutcome, VehicleSpec } from "@danypops/armada";
 import type { ServiceSpec } from "@danypops/vehicle-server/service";
 import type { DaemonServiceInstaller } from "../src/daemon/daemon-service.ts";
 import { createApp, type Deps } from "../src/daemon/service.ts";
@@ -123,6 +124,16 @@ class FakeDaemonServiceInstaller implements DaemonServiceInstaller {
 			return { ok: false, reason: this.restartResolveFailure, ...(this.restartNotADaemon ? { notADaemon: true } : {}) };
 		return { ok: true, restarted: this.restarted, reason: this.restartReason, spec: this.spec };
 	}
+	registeredVehicles: VehicleSpec[] = [];
+	unregisterByNameCalls: string[] = [];
+	async listRegisteredVehicles(): Promise<readonly VehicleSpec[]> {
+		return this.registeredVehicles;
+	}
+	async unregisterVehicleByName(name: string): Promise<VehicleRegistrationOutcome> {
+		this.unregisterByNameCalls.push(name);
+		this.registeredVehicles = this.registeredVehicles.filter((vehicle) => vehicle.name !== name);
+		return { ok: true, manifestHash: "hash" as never, applied: [], diagnostics: [] };
+	}
 }
 
 const roots: string[] = [];