@danypops/pi-packed 0.19.12 → 0.20.1

package/service/src/cli/cli.ts

@@ -8,6 +8,7 @@ import { formatDoctorReport, runDoctor } from "../adoption/doctor.ts";
 import { formatPackReport, NpmPackVerifier, type PackReport } from "../adoption/pack.ts";
 import { type AdoptionReport, formatAdoptionReport, scoreTarget } from "../adoption/score.ts";
 import type { PackageDaemonPort } from "../daemon/client.ts";
+import type { OperationOutputs } from "../daemon/service.ts";
 import { checkUpdates } from "../daemon/watcher.ts";
 import { generateIndex, indexPath, readIndex } from "../index/build-index.ts";
 import { syncCatalog } from "../packages/catalog.ts";
@@ -83,7 +84,7 @@ usage:
   packed search <query> [--offline] [--json]   search npm (or the local mirror with --offline)
   packed info <name> [--json]                  package details
   packed updates [--project <path>] [--json]   updates per the local mirror; --project also checks that project's own .pi/settings.json pins
-  packed update <source> [--approve] [--no-service] [--json]  update one configured package through Pi; restarts its registered persistent service (if any) to pick up the new code, unless --no-service
+  packed update <source> [--approve] [--json]  update one configured package through Pi and reconcile its registered Vehicle
   packed update --self [--approve] [--json]    update Packed itself (npm-global installs only) and restart its supervised service
   packed mirror [--json]                       sync upstream into the local SQLite index
   packed installed [--json]                    installed pi packages
@@ -100,9 +101,10 @@ usage:
   packed setup update [manifest] [--json]       deliberately refresh immutable package resolutions
   packed setup plan [manifest] [--prune] [--json] show an additive or exact setup diff without mutation
   packed setup apply [manifest] [--prune] [--approve] [--json] apply an approved setup plan
-  packed install <source> [--approve] [--no-service] [--json] pi install npm:|git:|https://… via daemon; auto-registers a detected npm: Vehicle daemon as a service unless --no-service
-  packed install-service <source> --approve [--json] register a package's own daemon as a persistent login/boot service (also useful standalone, e.g. re-registering after --no-service)
+  packed install <source> [--approve] [--json] pi install npm:|git:|https://… via daemon and reconcile any declared Vehicle
+  packed install-service <source> --approve [--json] reconcile a package's declared Vehicle
   packed restart-service <source> --approve [--json] restart a package's already-registered persistent service standalone (packed update already does this automatically)
+  packed reconcile-services --approve [--project <path>] [--json] sweep every installed package and self-heal its Vehicle registration (the daemon also runs this on its own interval and at startup)
   packed remove <name> [--approve] [--json]    remove by bare npm name via daemon
   packed security [always|never] [--approve] [--json] read or set mutation approval policy
   packed serve                                 run the long-running daemon
@@ -138,14 +140,12 @@ export interface CliDeps {
 		apply(manifestPath: string, options?: { prune?: boolean }): Promise<SetupApplyResult>;
 	};
 	daemonService?: {
-		install(
-			source: string,
-			approved?: boolean,
-		): Promise<{ output: string; spec?: { name: string; binPath: string; descriptorPath: string } }>;
+		install(source: string, approved?: boolean): Promise<{ output: string; spec?: { name: string; binPath: string } }>;
 		restart(
 			source: string,
 			approved?: boolean,
-		): Promise<{ output: string; restarted?: boolean; spec?: { name: string; binPath: string; descriptorPath: string } }>;
+		): Promise<{ output: string; restarted?: boolean; spec?: { name: string; binPath: string } }>;
+		reconcileAll(approved?: boolean, projectRoot?: string): Promise<OperationOutputs["package.reconcile_services"]>;
 	};
 	piVersion?: { check(): Promise<PiVersionReport> };
 	selfUpdater?: { run(): Promise<SelfUpdateReport> };
@@ -166,7 +166,6 @@ interface Flags {
 	force: boolean;
 	prune: boolean;
 	machineLocal: boolean;
-	noService: boolean;
 	ecosystem: boolean;
 	self: boolean;
 	project?: string;
@@ -183,7 +182,6 @@ function parseFlags(rest: string[]): { flags: Flags; pos: string[] } {
 		force: false,
 		prune: false,
 		machineLocal: false,
-		noService: false,
 		ecosystem: false,
 		self: false,
 	};
@@ -198,7 +196,6 @@ function parseFlags(rest: string[]): { flags: Flags; pos: string[] } {
 		else if (a === "--force") flags.force = true;
 		else if (a === "--prune") flags.prune = true;
 		else if (a === "--machine-local") flags.machineLocal = true;
-		else if (a === "--no-service") flags.noService = true;
 		else if (a === "--ecosystem") flags.ecosystem = true;
 		else if (a === "--self") flags.self = true;
 		else if (a === "--limit" && i + 1 < rest.length) flags.limit = Number(rest[++i]) || SEARCH_DEFAULT_LIMIT;
@@ -236,6 +233,7 @@ const PACKAGE_COMMAND_OPERATIONS: Record<string, PackageOperation | undefined> =
 	install: "install",
 	"install-service": "install_service",
 	"restart-service": "restart_service",
+	"reconcile-services": "reconcile_services",
 	remove: "remove",
 	pi: "pi.status",
 	advisories: "advisories.scan",
@@ -570,36 +568,14 @@ const commands: Record<string, { usage: string; run: Command }> = {
 	},
 
 	install: {
-		usage: "packed install npm:<pkg>[@ver] | git:<host>/<owner>/<repo>[@ref] | https://… [--no-service] [--json]",
+		usage: "packed install npm:<pkg>[@ver] | git:<host>/<owner>/<repo>[@ref] | https://… [--json]",
 		async run(_rest, d, flags, pos) {
 			const source = pos[0] ?? "";
 			if (!SOURCE_RE.test(source)) return usageErr(`usage: ${commands.install!.usage}\n`);
 			try {
 				const output = await d.inst.install(source, { approved: flags.approved });
-				// A package's own persistent-service registration piggybacks on the same
-				// approval already granted for install -- both are the same "code-execution"
-				// mutation tier, so this isn't a new consent surface. Silent for the
-				// overwhelmingly common case (most Pi packages aren't daemons at all);
-				// --no-service skips the attempt entirely, and a genuine failure (detected
-				// a daemon but couldn't register it) is reported without failing the
-				// install itself, which already succeeded.
-				let serviceInstall: { detected: true; ok: boolean; output: string } | undefined;
-				if (!flags.noService && source.startsWith("npm:") && d.daemonService) {
-					try {
-						const svc = await d.daemonService.install(source, flags.approved);
-						serviceInstall = { detected: true, ok: true, output: svc.output };
-					} catch (e) {
-						if (!(e instanceof Error) || !(e as { notADaemon?: boolean }).notADaemon) {
-							serviceInstall = { detected: true, ok: false, output: e instanceof Error ? e.message : String(e) };
-						}
-					}
-				}
-				if (flags.json) return ok(`${JSON.stringify({ ok: true, source, output, ...(serviceInstall ? { serviceInstall } : {}) })}\n`);
-				let human = `${output}\n`;
-				if (serviceInstall?.ok) human += `${serviceInstall.output}\n`;
-				else if (serviceInstall && !serviceInstall.ok)
-					human += `note: detected a persistent-service daemon but could not register it: ${serviceInstall.output}\n`;
-				return ok(human);
+				if (flags.json) return ok(`${JSON.stringify({ ok: true, source, output })}\n`);
+				return ok(`${output}\n`);
 			} catch (e) {
 				const error = e instanceof Error ? e.message : String(e);
 				return flags.json ? fail(`${JSON.stringify({ ok: false, source, error })}\n`) : fail(`${error}\n`);
@@ -640,6 +616,21 @@ const commands: Record<string, { usage: string; run: Command }> = {
 		},
 	},
 
+	"reconcile-services": {
+		usage:
+			"packed reconcile-services --approve [--project <path>] [--json]  (sweeps every installed package and self-heals its Vehicle registration through Armada)",
+		async run(_rest, d, flags) {
+			if (!d.daemonService) return fail("reconcile-services requires a running packed daemon\n");
+			try {
+				const result = await d.daemonService.reconcileAll(flags.approved, flags.project);
+				return flags.json ? ok(`${JSON.stringify(result)}\n`) : ok(`${result.output}\n`);
+			} catch (e) {
+				const error = e instanceof Error ? e.message : String(e);
+				return flags.json ? fail(`${JSON.stringify({ ok: false, error })}\n`) : fail(`${error}\n`);
+			}
+		},
+	},
+
 	security: {
 		usage: "packed security [always|never] [--json]",
 		async run(_rest, d, flags, pos) {
@@ -685,27 +676,10 @@ const commands: Record<string, { usage: string; run: Command }> = {
 						: `is already up to date${version ? ` at ${version}` : ""}`;
 					return ok(`${source} ${reason}\n`);
 				}
-				// Mirrors install's own auto-registration composition: same approval tier, silent for
-				// the common non-daemon case, a failure reported without failing the update itself.
-				let serviceRestart: { detected: true; ok: boolean; output: string } | undefined;
-				if (!flags.noService && source.startsWith("npm:") && d.daemonService) {
-					try {
-						const svc = await d.daemonService.restart(source, flags.approved);
-						serviceRestart = { detected: true, ok: true, output: svc.output };
-					} catch (e) {
-						if (!(e instanceof Error) || !(e as { notADaemon?: boolean }).notADaemon) {
-							serviceRestart = { detected: true, ok: false, output: e instanceof Error ? e.message : String(e) };
-						}
-					}
-				}
-				if (flags.json) return ok(`${JSON.stringify({ ok: true, source, ...outcome, ...(serviceRestart ? { serviceRestart } : {}) })}\n`);
+				if (flags.json) return ok(`${JSON.stringify({ ok: true, source, ...outcome })}\n`);
 				const transition =
 					outcome.previousVersion && outcome.currentVersion ? ` (${outcome.previousVersion} → ${outcome.currentVersion})` : "";
-				let human = `${outcome.output}${transition}\n`;
-				if (serviceRestart?.ok) human += `${serviceRestart.output}\n`;
-				else if (serviceRestart && !serviceRestart.ok)
-					human += `note: could not restart its persistent service: ${serviceRestart.output}\n`;
-				return ok(`${human}Reload Pi with /reload to activate the updated package.\n`);
+				return ok(`${outcome.output}${transition}\nReload Pi with /reload to activate the updated package.\n`);
 			} catch (error) {
 				const message = error instanceof Error ? error.message : String(error);
 				return flags.json
@@ -755,10 +729,7 @@ const commands: Record<string, { usage: string; run: Command }> = {
 	},
 };
 
-/** systemd user unit, delegating to vehicle-server's shared generateSystemdUnit -- idle self-exit
- * is disabled (PI_PACKED_IDLE_SECS=0) since systemd's own Restart=always takes over lifecycle. This
- * only ever prints (see the `service` command above); nothing here calls installUserService, so
- * descriptorPath is never actually read/written -- required by ServiceSpec's shape regardless. */
+/** Renders the legacy diagnostic unit without installing it; Armada owns service-manager mutation. */
 export function renderUnit(execPath: string, cliPath: string, piBin?: string): string {
 	// systemd does not read shell rc files: PI_BIN must be explicit so the
 	// daemon's install/remove execs can find the pi binary.
@@ -767,10 +738,11 @@ export function renderUnit(execPath: string, cliPath: string, piBin?: string): s
 	return generateSystemdUnit({
 		name: "pi-packed",
 		displayName: "pi-packed package service (Pi agent)",
+		version: VERSION,
 		binPath: execPath,
 		args: [cliPath, "serve"],
 		env,
-		descriptorPath: resolvePackedPaths().serviceDescriptor,
+		handlePath: resolvePackedPaths().handle,
 		// Packed's own client (connectPackageDaemon) never auto-spawns -- "start packed.service"
 		// or this unit's own systemd supervision is its only recovery path.
 		restartOnFailure: true,

package/service/src/daemon/client.ts

@@ -25,6 +25,7 @@ import type { OperationInputs, OperationName, OperationOutputs } from "./service
 
 export type FetchTransport = (request: Request) => Promise<Response>;
 type RpcClient = AuthenticatedRpcClient<OperationName, OperationInputs, OperationOutputs>;
+type ServiceSummary = { name: string; binPath: string };
 
 export interface PackageDaemonPort {
 	search(query: string, limit: number, offline?: boolean): Promise<{ query: string; total: number; results: SearchPage["results"] }>;
@@ -46,14 +47,9 @@ export interface PackageDaemonPort {
 	security(): Promise<SecuritySettings>;
 	setMutationApproval(value: MutationApproval, approved?: boolean): Promise<SecuritySettings>;
 	install(source: string, approved?: boolean): Promise<string>;
-	installService(
-		source: string,
-		approved?: boolean,
-	): Promise<{ output: string; spec?: { name: string; binPath: string; descriptorPath: string } }>;
-	restartService(
-		source: string,
-		approved?: boolean,
-	): Promise<{ output: string; restarted?: boolean; spec?: { name: string; binPath: string; descriptorPath: string } }>;
+	installService(source: string, approved?: boolean): Promise<{ output: string; spec?: ServiceSummary }>;
+	restartService(source: string, approved?: boolean): Promise<{ output: string; restarted?: boolean; spec?: ServiceSummary }>;
+	reconcileServices(approved?: boolean, projectRoot?: string): Promise<OperationOutputs["package.reconcile_services"]>;
 	remove(name: string, approved?: boolean): Promise<string>;
 	update(source: string, approved?: boolean): Promise<UpdateOutcome>;
 	piStatus(): Promise<PiVersionReport>;
@@ -230,10 +226,7 @@ export class PackageDaemonClient implements PackageDaemonPort {
 		return result.output;
 	}
 
-	async installService(
-		source: string,
-		approved = false,
-	): Promise<{ output: string; spec?: { name: string; binPath: string; descriptorPath: string } }> {
+	async installService(source: string, approved = false): Promise<{ output: string; spec?: ServiceSummary }> {
 		const result = await this.call("package.install_service", { source, approved });
 		if (!result.ok)
 			throw new PackageDaemonError(
@@ -248,7 +241,7 @@ export class PackageDaemonClient implements PackageDaemonPort {
 	async restartService(
 		source: string,
 		approved = false,
-	): Promise<{ output: string; restarted?: boolean; spec?: { name: string; binPath: string; descriptorPath: string } }> {
+	): Promise<{ output: string; restarted?: boolean; spec?: ServiceSummary }> {
 		const result = await this.call("package.restart_service", { source, approved });
 		if (!result.ok)
 			throw new PackageDaemonError(
@@ -260,6 +253,12 @@ export class PackageDaemonClient implements PackageDaemonPort {
 		return { output: result.output, restarted: result.restarted, spec: result.spec };
 	}
 
+	async reconcileServices(approved = false, projectRoot?: string): Promise<OperationOutputs["package.reconcile_services"]> {
+		const result = await this.call("package.reconcile_services", { approved, projectRoot });
+		if (!result.ok) throw new PackageDaemonError(result.output || "failed to reconcile Vehicle services", "package.reconcile_services");
+		return result;
+	}
+
 	async remove(name: string, approved = false): Promise<string> {
 		const result = await this.call("package.remove", { name, approved });
 		if (!result.ok) throw new PackageDaemonError(result.output || `failed to remove ${name}`, "package.remove");
@@ -319,14 +318,9 @@ export class DaemonBackedInstaller implements Installer {
 }
 
 export interface DaemonServiceInstallerPort {
-	install(
-		source: string,
-		approved?: boolean,
-	): Promise<{ output: string; spec?: { name: string; binPath: string; descriptorPath: string } }>;
-	restart(
-		source: string,
-		approved?: boolean,
-	): Promise<{ output: string; restarted?: boolean; spec?: { name: string; binPath: string; descriptorPath: string } }>;
+	install(source: string, approved?: boolean): Promise<{ output: string; spec?: ServiceSummary }>;
+	restart(source: string, approved?: boolean): Promise<{ output: string; restarted?: boolean; spec?: ServiceSummary }>;
+	reconcileAll(approved?: boolean, projectRoot?: string): Promise<OperationOutputs["package.reconcile_services"]>;
 }
 
 export class DaemonBackedDaemonServiceInstaller implements DaemonServiceInstallerPort {
@@ -334,15 +328,15 @@ export class DaemonBackedDaemonServiceInstaller implements DaemonServiceInstalle
 	async restart(
 		source: string,
 		approved?: boolean,
-	): Promise<{ output: string; restarted?: boolean; spec?: { name: string; binPath: string; descriptorPath: string } }> {
+	): Promise<{ output: string; restarted?: boolean; spec?: ServiceSummary }> {
 		return (await connectPackageDaemon(this.paths)).restartService(source, approved);
 	}
-	async install(
-		source: string,
-		approved?: boolean,
-	): Promise<{ output: string; spec?: { name: string; binPath: string; descriptorPath: string } }> {
+	async install(source: string, approved?: boolean): Promise<{ output: string; spec?: ServiceSummary }> {
 		return (await connectPackageDaemon(this.paths)).installService(source, approved);
 	}
+	async reconcileAll(approved?: boolean, projectRoot?: string): Promise<OperationOutputs["package.reconcile_services"]> {
+		return (await connectPackageDaemon(this.paths)).reconcileServices(approved, projectRoot);
+	}
 }
 
 export class DaemonRegistry implements Registry {

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

@@ -26,25 +26,30 @@
  * on disk instead of asking for one more declaration.
  */
 import { readFileSync } from "node:fs";
-import { basename, join } from "node:path";
+import { join } from "node:path";
+import { createVehicleRegistrar, type VehicleRegistrar } from "@danypops/armada";
 import { resolveDaemonPaths } from "@danypops/vehicle-server/paths";
 import {
-	createNodeServiceInstallDeps,
-	installUserService,
-	isServiceInstalled,
-	type ServiceInstallDeps,
+	isVehicleServiceRegistered,
+	registerVehicleService,
 	type ServiceInstallResult,
 	type ServiceSpec,
+	unregisterVehicleService,
 } from "@danypops/vehicle-server/service";
-import { npmPackageName } from "../packages/installed.ts";
+import { npmPackageName, readInstalledPackagesAcrossScopes } from "../packages/installed.ts";
 
 export interface DaemonServiceManifest {
 	/** Relative to the installed package's own root directory. */
 	binPath: string;
 	args?: string[];
-	/** Defaults to the bare npm package name (scope stripped). Used for the state-directory/unit name, matching each package's own service-install convention (e.g. web-spider.service). */
+	/** Defaults to the bare npm package name (scope stripped). */
 	name?: string;
 	displayName?: string;
+	/** Runtime handle filename inside the Vehicle's XDG runtime directory. */
+	handleFilename?: string;
+	workingDirectory?: string;
+	restartOnFailure?: boolean;
+	restartSec?: number;
 }
 
 export type ResolveDaemonServiceResult =
@@ -63,10 +68,16 @@ interface ResolvedDaemonEntrypoint {
 	args?: string[];
 	name: string;
 	displayName?: string;
+	handleFilename?: string;
+	workingDirectory?: string;
+	restartOnFailure?: boolean;
+	restartSec?: number;
+	version: string;
 }
 
 interface InstalledPackageJson {
 	name?: string;
+	version?: string;
 	bin?: string | Record<string, string>;
 	dependencies?: Record<string, string>;
 	packed?: { daemonService?: DaemonServiceManifest };
@@ -122,8 +133,8 @@ export function detectVehicleDaemonService(
 	if (!own) return undefined;
 
 	const ownBin = firstBinPath(own);
-	if (ownBin && dependsOnVehicle(own)) {
-		return { binPath: join(packageDir, ownBin), args: ["serve"], name: unscopedName(own.name ?? fallbackName) };
+	if (ownBin && dependsOnVehicle(own) && own.version) {
+		return { binPath: join(packageDir, ownBin), args: ["serve"], name: unscopedName(own.name ?? fallbackName), version: own.version };
 	}
 
 	for (const depName of Object.keys(own.dependencies ?? {})) {
@@ -135,8 +146,8 @@ export function detectVehicleDaemonService(
 			const dep = readPackageJson(depDir);
 			if (!dep) continue;
 			const depBin = firstBinPath(dep);
-			if (depBin && dependsOnVehicle(dep)) {
-				return { binPath: join(depDir, depBin), args: ["serve"], name: unscopedName(dep.name ?? depName) };
+			if (depBin && dependsOnVehicle(dep) && dep.version) {
+				return { binPath: join(depDir, depBin), args: ["serve"], name: unscopedName(dep.name ?? depName), version: dep.version };
 			}
 		}
 	}
@@ -146,20 +157,21 @@ export function detectVehicleDaemonService(
 function buildSpec(entry: ResolvedDaemonEntrypoint): ServiceSpec {
 	const paths = resolveDaemonPaths({
 		stateDirectoryName: entry.name,
-		// Only serviceDescriptor is used below; these three exist purely to
-		// satisfy resolveDaemonPaths()'s shared shape for a package this
-		// module never opens the db/token/handle of.
 		databaseFilename: "unused.db",
 		tokenFilename: "unused-token",
-		handleFilename: "unused-handle.json",
+		handleFilename: entry.handleFilename ?? "handle.json",
 		systemdUnitName: `${entry.name}.service`,
 	});
 	return {
 		name: entry.name,
 		displayName: entry.displayName,
+		version: entry.version,
 		binPath: entry.binPath,
 		args: entry.args,
-		descriptorPath: paths.serviceDescriptor,
+		handlePath: paths.handle,
+		workingDirectory: entry.workingDirectory,
+		...(entry.restartOnFailure === undefined ? {} : { restartOnFailure: entry.restartOnFailure }),
+		...(entry.restartSec === undefined ? {} : { restartSec: entry.restartSec }),
 	};
 }
 
@@ -187,6 +199,11 @@ export function resolveDaemonServiceSpec(piHome: string, source: string): Resolv
 				args: manifest.args,
 				name: manifest.name ?? unscopedName(packageName),
 				displayName: manifest.displayName,
+				handleFilename: manifest.handleFilename,
+				workingDirectory: manifest.workingDirectory,
+				restartOnFailure: manifest.restartOnFailure,
+				restartSec: manifest.restartSec,
+				version: pkg.version ?? "0.0.0",
 			}),
 		};
 	}
@@ -201,49 +218,122 @@ export function resolveDaemonServiceSpec(piHome: string, source: string): Resolv
 	};
 }
 
+export interface ReconcileAllResult {
+	reconciled: Array<{ packageName: string; vehicleName: string; installed: boolean; reason?: string }>;
+	skipped: number;
+	failed: Array<{ packageName: string; reason: string }>;
+}
+
+/** Matches readPackageDeclarations' own bound -- a reconcile-all sweep never processes an unbounded package list. */
+const MAX_RECONCILE_PACKAGES = 500;
+
+/**
+ * Sweeps every installed Packed package (global scope, plus a project's own
+ * pins when projectRoot is given), resolves each to a Vehicle-shaped daemon
+ * exactly as install()/restart() already do per-package, and upserts +
+ * reconciles it through Armada. This is what makes Armada authoritative for
+ * every Vehicle Packed knows about, not just the one source a single
+ * install/update call happened to touch -- it also self-heals a Vehicle
+ * whose daemon package version bumped as someone else's transitive
+ * dependency, and a Vehicle a prior Packed version never registered at all.
+ * Idempotent and safe to call unconditionally: a non-daemon package costs
+ * one or two file reads (see resolveDaemonServiceSpec) and never reaches
+ * Armada. Two packages that resolve to the same Vehicle (a Pi extension and
+ * its own daemon dependency, both separately Packed-tracked) reconcile it
+ * once, not twice.
+ */
+export async function reconcileAllDaemonServices(
+	piHome: string,
+	projectRoot: string | undefined,
+	installer: Pick<DaemonServiceInstaller, "install">,
+): Promise<ReconcileAllResult> {
+	const packages = readInstalledPackagesAcrossScopes(piHome, projectRoot).slice(0, MAX_RECONCILE_PACKAGES);
+	const reconciled: ReconcileAllResult["reconciled"] = [];
+	const failed: ReconcileAllResult["failed"] = [];
+	const seen = new Set<string>();
+	let skipped = 0;
+	for (const pkg of packages) {
+		const resolved = await installer.install(piHome, `npm:${pkg.name}`);
+		if (!resolved.ok) {
+			if (resolved.notADaemon) {
+				skipped++;
+				continue;
+			}
+			failed.push({ packageName: pkg.name, reason: resolved.reason });
+			continue;
+		}
+		if (seen.has(resolved.spec.name)) continue;
+		seen.add(resolved.spec.name);
+		reconciled.push({
+			packageName: pkg.name,
+			vehicleName: resolved.spec.name,
+			installed: resolved.result.installed,
+			...(resolved.result.installed ? {} : { reason: resolved.result.reason }),
+		});
+	}
+	return { reconciled, skipped, failed };
+}
+
 export interface DaemonServiceInstaller {
 	install(
 		piHome: string,
 		source: string,
-	): { ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean };
+	): Promise<{ ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }>;
+	remove(
+		piHome: string,
+		source: string,
+	): Promise<{ ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }>;
 	restart(
 		piHome: string,
 		source: string,
-	): { ok: true; restarted: boolean; reason?: string; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean };
+	): Promise<{ ok: true; restarted: boolean; reason?: string; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }>;
 }
 
+/**
+ * Calls Armada's own VehicleRegistrar directly (in-process), rather than
+ * shelling out to its CLI as a subprocess -- the same registration logic
+ * `@danypops/armada` exposes to any other library consumer, not a Packed-
+ * specific reimplementation. One registrar per instance so its manifest
+ * path/native controller are resolved once, not on every call.
+ */
 export class RealDaemonServiceInstaller implements DaemonServiceInstaller {
-	install(
+	constructor(private readonly registrar: VehicleRegistrar = createVehicleRegistrar()) {}
+
+	async install(
 		piHome: string,
 		source: string,
-	): { ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean } {
+	): Promise<{ ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }> {
 		const resolved = resolveDaemonServiceSpec(piHome, source);
 		if (!resolved.ok) return resolved;
-		const result = installUserService(resolved.spec, createNodeServiceInstallDeps());
+		const result = await registerVehicleService(resolved.spec, this.registrar);
 		return { ok: true, result, spec: resolved.spec };
 	}
 
-	restart(
+	async remove(
+		piHome: string,
+		source: string,
+	): Promise<{ ok: true; result: ServiceInstallResult; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean }> {
+		const resolved = resolveDaemonServiceSpec(piHome, source);
+		if (!resolved.ok) return resolved;
+		const result = await unregisterVehicleService(resolved.spec.name, this.registrar);
+		return { ok: true, result, spec: resolved.spec };
+	}
+
+	async restart(
 		piHome: string,
 		source: string,
-	): { ok: true; restarted: boolean; reason?: string; spec: ServiceSpec } | { ok: false; reason: string; notADaemon?: boolean } {
+	): 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;
-		const deps = createNodeServiceInstallDeps();
-		if (!isServiceInstalled(resolved.spec, deps)) {
+		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 };
 		}
-		const result = restartUserService(resolved.spec, deps);
-		return { ok: true, restarted: result.restarted, reason: result.reason, spec: resolved.spec };
+		const result = await registerVehicleService(resolved.spec, this.registrar);
+		return {
+			ok: true,
+			restarted: result.installed,
+			...(result.installed ? {} : { reason: result.reason }),
+			spec: resolved.spec,
+		};
 	}
 }
-
-/** Linux/systemd only, matching installUserService's platform coverage order -- macOS/Windows report unsupported rather than guessing at launchctl/reg.exe restart equivalents this module doesn't implement. */
-export function restartUserService(spec: ServiceSpec, deps: ServiceInstallDeps): { restarted: boolean; reason?: string } {
-	const platform = deps.platform ?? process.platform;
-	if (platform !== "linux")
-		return { restarted: false, reason: `restart is not supported on platform "${platform}" yet -- restart ${spec.name} manually` };
-	const result = deps.runCommand("systemctl", ["--user", "restart", basename(spec.descriptorPath)]);
-	if (!result.ok) return { restarted: false, reason: `systemctl --user restart failed: ${result.output}` };
-	return { restarted: true };
-}

package/service/src/daemon/daemon.ts

@@ -7,6 +7,7 @@ import {
 	startDaemon,
 } from "@danypops/vehicle-server/daemon";
 import { ensureAuthToken } from "@danypops/vehicle-server/paths";
+import { type DaemonServiceInstaller, RealDaemonServiceInstaller, reconcileAllDaemonServices } from "./daemon-service.ts";
 import { generateIndex, indexPath, indexStatus } from "../index/build-index.ts";
 import { catalogStatus, syncCatalog } from "../packages/catalog.ts";
 import { latestVersion, openDb } from "../packages/db.ts";
@@ -19,6 +20,7 @@ import {
 	ENV,
 	IDLE_BUDGET_DEFAULT_MS,
 	INDEX_INTERVAL_DEFAULT_MS,
+	RECONCILE_INTERVAL_DEFAULT_MS,
 	WATCH_INTERVAL_DEFAULT_MS,
 	WATCHDOG_TICK_MS,
 } from "../shared/constants.ts";
@@ -35,12 +37,13 @@ export interface StartPackedDaemonOptions {
 	reg?: Registry;
 	inst?: Installer;
 	piHome?: string;
+	daemonServiceInstaller?: DaemonServiceInstaller;
 	maintenanceTasks?: MaintenanceTask[];
 	idleBudgetMs?: number;
 	migrateLegacy?: boolean;
 }
 
-function daemonOptions(options: StartPackedDaemonOptions): StartDaemonOptions {
+export function daemonOptions(options: StartPackedDaemonOptions): StartDaemonOptions {
 	const paths = options.paths ?? resolvePackedPaths();
 	if (options.migrateLegacy ?? options.paths === undefined) migrateLegacyPackedState(paths, legacyPackedStateDirectory());
 	const token = ensureAuthToken(paths.token, "Packed");
@@ -48,6 +51,7 @@ function daemonOptions(options: StartPackedDaemonOptions): StartDaemonOptions {
 	const inst = options.inst ?? new ExecInstaller();
 	const piHome = options.piHome ?? defaultPiHome();
 	const database = openDb(paths.database);
+	const daemonServiceInstaller = options.daemonServiceInstaller ?? new RealDaemonServiceInstaller();
 	const configuredMaintenanceTasks = options.maintenanceTasks ?? [
 		{
 			name: "package-update-check",
@@ -75,6 +79,24 @@ function daemonOptions(options: StartPackedDaemonOptions): StartDaemonOptions {
 				if (indexStatus(indexPath(dataDirectory), ttlMs).stale) await generateIndex(reg, dataDirectory, indexPath(dataDirectory));
 			},
 		},
+		{
+			// Self-heals a Vehicle a running daemon never picked up -- an out-of-band
+			// npm install/update, or a transitive dependency bump that resolveDaemonServiceSpec
+			// would only otherwise re-check the next time /install or /restart-service ran
+			// for that exact package.
+			name: "vehicle-reconcile",
+			intervalMs: envMs(ENV.RECONCILE_SECS, RECONCILE_INTERVAL_DEFAULT_MS),
+			run: async () => {
+				const result = await reconcileAllDaemonServices(piHome, undefined, daemonServiceInstaller);
+				if (result.failed.length > 0) {
+					logger.warn("vehicle-reconcile completed with failures", {
+						reconciled: result.reconciled.length,
+						skipped: result.skipped,
+						failed: result.failed.length,
+					});
+				}
+			},
+		},
 	];
 	const maintenanceTasks = configuredMaintenanceTasks.filter((task) => task.intervalMs > 0);
 
@@ -93,7 +115,7 @@ function daemonOptions(options: StartPackedDaemonOptions): StartDaemonOptions {
 		maintenanceTasks,
 		idleBudgetMs: options.idleBudgetMs ?? envMs(ENV.IDLE_SECS, IDLE_BUDGET_DEFAULT_MS),
 		idleTickMs: WATCHDOG_TICK_MS,
-		buildApp: () => createApp({ reg, inst, token, stateDir: paths.stateDirectory, dataDir: dirname(paths.database), piHome }),
+		buildApp: () => createApp({ reg, inst, token, stateDir: paths.stateDirectory, dataDir: dirname(paths.database), piHome, daemonServiceInstaller }),
 		onShutdown: () => database.close(),
 	};
 }