@danypops/pi-packed 0.19.10 → 0.19.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-packed",
-  "version": "0.19.10",
+  "version": "0.19.12",
   "description": "Pi package lifecycle, validation, daemon, tools, profiles, and TUI",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "typecheck": "bunx tsc --noEmit"
   },
   "dependencies": {
-    "@danypops/packed": "workspace:*",
+    "@danypops/packed": "^0.6.0",
     "@danypops/pi-extension-harness": "^0.2.0",
     "@danypops/vehicle-client": "^0.2.0",
     "@danypops/vehicle-core": "^0.6.1",

package/service/src/adoption/check.ts

@@ -487,11 +487,40 @@ function cleanupManifestCheck(context: Context): void {
 	}
 }
 
+/** A conventional test file (path under a test/tests/__tests__ directory, or
+ * a .test./.spec. basename) never runs on a consumer's machine at
+ * install/import time -- it has no bearing on what a package's *shipped
+ * runtime* code actually imports, even though npm's own `files` field
+ * (a plain directory-prefix allowlist, e.g. "service") has no way to exclude
+ * it short of a package author remembering to. Real bug this fixes: a test
+ * file's own fixture data can contain string literals shaped exactly like
+ * real import statements (deliberately, to test this very checker's
+ * detection logic) without being real imports of the file that contains them. */
+function isTestFile(path: string): boolean {
+	if (/(?:^|\/)(?:test|tests|__tests__)\//.test(path)) return true;
+	return /\.(?:test|spec)\.[cm]?[jt]sx?$/.test(path);
+}
+
 /** Shipped .js/.ts/.cjs/.mjs files that are actually contained within the
- * package root (never a symlink escape) -- the same file universe every
- * source-scanning check works over. */
+ * package root (never a symlink escape), excluding test files -- the same
+ * file universe every source-scanning check works over. */
 function shippedSourceFiles(context: Context): string[] {
-	return shippedFiles(context).filter((path) => /\.[cm]?[jt]s$/.test(path) && isContainedFile(context.root, path));
+	return shippedFiles(context).filter(
+		(path) => /\.[cm]?[jt]s$/.test(path) && !isTestFile(path) && isContainedFile(context.root, path),
+	);
+}
+
+/**
+ * Strips line and block comments before the import-specifier regex below runs
+ * -- a comment can contain an arbitrary quoted "from ..." substring the regex
+ * would otherwise match as if it were real code (confirmed live against a
+ * JSDoc comment describing a bug fix in prose that happened to contain
+ * exactly that shape). Not a full lexer: a string literal that itself
+ * contains a comment delimiter could still confuse this, a pre-existing
+ * limit of a regex-based scan, not a regression this introduces.
+ */
+function stripComments(source: string): string {
+	return source.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, "");
 }
 
 /** Every import/require specifier literal in one file, bounded by
@@ -500,7 +529,7 @@ function shippedSourceFiles(context: Context): string[] {
 function importSpecifiersIn(context: Context, file: string): string[] | undefined {
 	const absolute = join(context.root, file);
 	if (lstatSync(absolute).size > MAX_SOURCE_BYTES) return undefined;
-	const source = readFileSync(absolute, "utf8");
+	const source = stripComments(readFileSync(absolute, "utf8"));
 	return [...source.matchAll(/(?:from\s*|import\s*\(|require\s*\()\s*["']([^"']+)["']/g)].map((match) => match[1]!);
 }
 
@@ -523,6 +552,12 @@ function dependencyCheck(context: Context): void {
 		for (const specifier of importSpecifiersIn(context, file) ?? []) {
 			if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("node:") || specifier.startsWith("bun:")) continue;
 			const name = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0]!;
+			// A package importing its own subpath exports (e.g. "@scope/pkg/client")
+			// is not a runtime dependency on itself -- there is no real range to
+			// declare, and node/bun resolve a self-reference via the package's own
+			// name field, not a node_modules entry that a `dependencies` line would
+			// describe.
+			if (name === context.pkg.name) continue;
 			if (CORE_PACKAGES.has(name)) {
 				if (peers[name] !== "*")
 					context.add({

package/service/src/adoption/doctor.ts

@@ -7,7 +7,9 @@
  * answers the same question proactively, before pi ever runs.
  */
 import { join } from "node:path";
+import { createNodeServiceInstallDeps } from "@danypops/vehicle-server/service";
 import { listPackageResources, type PackageResources, resolveInstalledDir } from "../packages/resources.ts";
+import { checkServiceUnitPaths, type ServiceUnitDiagnostic } from "./service-doctor.ts";
 import { runExtensionSmoke, type SmokeOptions, type SmokeRegistrations } from "./smoke.ts";
 
 const REGISTRATION_KINDS = ["tools", "commands", "shortcuts", "flags"] as const;
@@ -50,6 +52,8 @@ export interface DoctorReport {
 	extensions: DoctorExtensionResult[];
 	scanned: number;
 	truncated: boolean;
+	/** A daemon-backed package's systemd --user unit referencing a path that no longer exists on disk -- see service-doctor.ts. Empty (not omitted) on a platform without systemd --user coverage. */
+	serviceUnits: ServiceUnitDiagnostic[];
 }
 
 interface ScanJob {
@@ -112,7 +116,16 @@ export async function runDoctor(piHome: string, projectRoot?: string, options: S
 	}
 	conflicts.sort((a, b) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name));
 
-	return { ok: conflicts.length === 0 && !anyNotOk, conflicts, extensions, scanned: bounded.length, truncated };
+	const serviceReport = checkServiceUnitPaths(piHome, projectRoot, createNodeServiceInstallDeps());
+
+	return {
+		ok: conflicts.length === 0 && !anyNotOk && serviceReport.ok,
+		conflicts,
+		extensions,
+		scanned: bounded.length,
+		truncated,
+		serviceUnits: serviceReport.diagnostics,
+	};
 }
 
 function formatClaimant(claim: DoctorClaim): string {
@@ -130,6 +143,9 @@ export function formatDoctorReport(report: DoctorReport, json: boolean): string
 		if (extension.status === "ok") continue;
 		out += `\n${extension.status.toUpperCase()} ${formatClaimant({ name: extension.name, source: extension.source, scope: extension.scope, extension: extension.extension })}${extension.message ? `: ${extension.message}` : ""}\n`;
 	}
+	for (const diagnostic of report.serviceUnits) {
+		out += `\n${diagnostic.severity.toUpperCase()} ${diagnostic.code} ${diagnostic.package} (${diagnostic.unitName}.service): ${diagnostic.message}\n`;
+	}
 	if (report.truncated) out += "\nOutput truncated: more enabled extensions exist than this run's bound.\n";
 	return out;
 }

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

@@ -0,0 +1,128 @@
+/**
+ * service-doctor.ts — checks every installed package's own daemon systemd
+ * --user unit (if one is registered) for an ExecStart path that no longer
+ * exists on disk. A unit is written once, at install/service-install time,
+ * and never re-validated against the package's current on-disk layout --
+ * confirmed live: a refactor that moved a package's own CLI entrypoint left
+ * a real, already-registered unit pointing at a deleted file. The process
+ * kept running only because it had been loaded into memory before the file
+ * vanished; the next crash or reboot would have failed to restart at all,
+ * silently, until someone happened to notice the daemon was down.
+ *
+ * Deliberately separate from doctor.ts's own DoctorReport (extension
+ * registration-conflict scanning) -- a different subject (installed
+ * services vs. loaded extensions), composed alongside it in runDoctor()
+ * rather than folded into its shape.
+ */
+import { existsSync } from "node:fs";
+import type { ServiceInstallDeps } from "@danypops/vehicle-server/service";
+import { isServiceInstalled } 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_EXEC_UNPARSEABLE";
+	severity: "error" | "warning";
+	package: string;
+	unitName: string;
+	message: string;
+}
+
+export interface ServiceDoctorReport {
+	ok: boolean;
+	diagnostics: ServiceUnitDiagnostic[];
+	checked: number;
+}
+
+/**
+ * Tokenizes ExecStart's own shell-quoted argument list -- matching
+ * generateSystemdUnit's shellQuote, which wraps every argument in double
+ * quotes and backslash-escapes only ", \, $, and ` inside them. Returns
+ * undefined for a missing or unrecognizable ExecStart line rather than
+ * guessing; the caller degrades that to a warning, never a false error.
+ */
+export function parseExecStartTokens(unitText: string): string[] | undefined {
+	const line = unitText.split("\n").find((entry) => entry.trimStart().startsWith("ExecStart="));
+	if (!line) return undefined;
+	const raw = line.slice(line.indexOf("=") + 1);
+	const tokens: string[] = [];
+	const pattern = /"((?:[^"\\]|\\.)*)"/g;
+	let match: RegExpExecArray | null = pattern.exec(raw);
+	while (match !== null) {
+		tokens.push(match[1]!.replace(/\\(["\\$`])/g, "$1"));
+		match = pattern.exec(raw);
+	}
+	return tokens.length > 0 ? tokens : undefined;
+}
+
+/** A token worth existence-checking is one that's actually path-shaped -- a bare word like "serve" (a real subcommand argument, not a path) would otherwise resolve relative to this check's own cwd and produce a false SERVICE_EXEC_PATH_MISSING. */
+function looksLikePath(token: string): boolean {
+	return token.includes("/");
+}
+
+export interface ServiceDoctorDeps extends Pick<ServiceInstallDeps, "fileExists" | "readFile"> {
+	platform?: string;
+}
+
+/**
+ * For every installed package that resolves to a real Vehicle daemon spec
+ * (same resolution daemon-service.ts's own install/restart commands use)
+ * and currently has a systemd --user unit registered, reads that unit's
+ * actual on-disk ExecStart (not a freshly recomputed "correct" one -- the
+ * whole point is catching a real unit that has drifted from what's true
+ * today) and flags any referenced path that no longer exists.
+ *
+ * Linux/systemd only, matching installUserService's own platform coverage
+ * -- macOS/Windows unit shapes differ and aren't checked here yet.
+ */
+export function checkServiceUnitPaths(piHome: string, projectRoot: string | undefined, deps: ServiceDoctorDeps): ServiceDoctorReport {
+	const diagnostics: ServiceUnitDiagnostic[] = [];
+	const platform = deps.platform ?? process.platform;
+	let checked = 0;
+	if (platform !== "linux") return { ok: true, diagnostics, checked };
+
+	for (const pkg of readInstalledPackagesAcrossScopes(piHome, projectRoot)) {
+		const resolved = resolveDaemonServiceSpec(piHome, `npm:${pkg.name}`);
+		if (!resolved.ok) continue;
+		const spec = resolved.spec;
+		if (!isServiceInstalled(spec, deps as ServiceInstallDeps)) continue;
+		checked++;
+
+		const unitText = deps.readFile(spec.descriptorPath);
+		if (unitText === null) continue; // isServiceInstalled said yes but the read raced/failed -- transient, not a real finding.
+
+		const tokens = parseExecStartTokens(unitText);
+		if (!tokens) {
+			diagnostics.push({
+				code: "SERVICE_EXEC_UNPARSEABLE",
+				severity: "warning",
+				package: pkg.name,
+				unitName: spec.name,
+				message: `could not parse ExecStart in ${spec.descriptorPath}`,
+			});
+			continue;
+		}
+
+		for (const token of tokens) {
+			if (!looksLikePath(token) || existsSync(token)) continue;
+			diagnostics.push({
+				code: "SERVICE_EXEC_PATH_MISSING",
+				severity: "error",
+				package: pkg.name,
+				unitName: spec.name,
+				message: `${spec.name}.service's ExecStart references a path that no longer exists: ${token} -- the service will fail to (re)start the next time it stops. Reinstall it (packed install-service npm:${pkg.name}) to regenerate.`,
+			});
+		}
+	}
+
+	return { ok: diagnostics.every((diagnostic) => diagnostic.severity !== "error"), diagnostics, checked };
+}
+
+export function formatServiceDoctorReport(report: ServiceDoctorReport, json: boolean): string {
+	if (json) return `${JSON.stringify(report)}\n`;
+	let out = `${report.ok ? "PASS" : "FAIL"} — ${report.checked} service unit(s) checked, ${report.diagnostics.length} issue(s)\n`;
+	for (const diagnostic of report.diagnostics) {
+		out += `${diagnostic.severity.toUpperCase()} ${diagnostic.code} ${diagnostic.package} (${diagnostic.unitName}.service): ${diagnostic.message}\n`;
+	}
+	return out;
+}

package/service/test/check.test.ts

@@ -366,3 +366,79 @@ describe("packed check", () => {
 		expect(codes(report.diagnostics)).toEqual(["PKG_JSON_INVALID"]);
 	});
 });
+
+describe("dependencyCheck false-positive regressions (packed check)", () => {
+	it("never scans a test file's own fixture strings as if they were real imports of that file", async () => {
+		// A checker's own test suite legitimately contains string literals shaped exactly
+		// like real import statements (fixture data for testing detection itself) -- these
+		// must never be attributed to the test file that merely contains them as text.
+		const root = fixture(
+			{ ...base, files: ["extensions", "test", "README.md", "LICENSE"] },
+			{
+				"extensions/index.ts": "export default function () {}",
+				"test/check.test.ts": 'const fixtureSource = \'import lodash from "lodash";\';\n',
+				"README.md": "# Example",
+				LICENSE: "MIT",
+			},
+		);
+		const report = await checkPackage(root, { generic: false });
+		expect(codes(report.diagnostics)).not.toContain("RUNTIME_DEPENDENCY_MISSING");
+	});
+
+	it("never scans a test-directory file outside a *.test.ts basename either (e.g. a shared test helper)", async () => {
+		const root = fixture(
+			{ ...base, files: ["extensions", "test", "README.md", "LICENSE"] },
+			{
+				"extensions/index.ts": "export default function () {}",
+				"test/helper.ts": 'import leftpad from "leftpad";\n',
+				"README.md": "# Example",
+				LICENSE: "MIT",
+			},
+		);
+		const report = await checkPackage(root, { generic: false });
+		expect(codes(report.diagnostics)).not.toContain("RUNTIME_DEPENDENCY_MISSING");
+	});
+
+	it("never treats a quoted 'from ...' phrase inside a comment as a real import specifier", async () => {
+		const root = fixture(
+			{ ...base, files: ["extensions", "README.md", "LICENSE"] },
+			{
+				"extensions/index.ts":
+					'/**\n * migrated "latest" from "some-package that looks like an import"\n */\nexport default function () {}\n',
+				"README.md": "# Example",
+				LICENSE: "MIT",
+			},
+		);
+		const report = await checkPackage(root, { generic: false });
+		expect(codes(report.diagnostics)).not.toContain("RUNTIME_DEPENDENCY_MISSING");
+	});
+
+	it("still catches a real RUNTIME_DEPENDENCY_MISSING import sitting right next to a misleading comment", async () => {
+		const root = fixture(
+			{ ...base, files: ["extensions", "README.md", "LICENSE"] },
+			{
+				"extensions/index.ts":
+					'// migrated "latest" from "totally not a real package"\nimport real from "real-missing-dep";\nexport default function () { return real; }\n',
+				"README.md": "# Example",
+				LICENSE: "MIT",
+			},
+		);
+		const report = await checkPackage(root, { generic: false });
+		expect(codes(report.diagnostics)).toContain("RUNTIME_DEPENDENCY_MISSING");
+		const diagnostic = report.diagnostics.find((d) => d.code === "RUNTIME_DEPENDENCY_MISSING")!;
+		expect(diagnostic.message).toContain("real-missing-dep");
+	});
+
+	it("never flags a package's own self-import of its own subpath export as a missing runtime dependency", async () => {
+		const root = fixture(
+			{ ...base, name: "@scope/self-ref", files: ["extensions", "README.md", "LICENSE"] },
+			{
+				"extensions/index.ts": 'import { thing } from "@scope/self-ref/client";\nexport default function () { return thing; }\n',
+				"README.md": "# Example",
+				LICENSE: "MIT",
+			},
+		);
+		const report = await checkPackage(root, { generic: false });
+		expect(codes(report.diagnostics)).not.toContain("RUNTIME_DEPENDENCY_MISSING");
+	});
+});

package/service/test/cli.test.ts

@@ -898,7 +898,7 @@ describe("CLI", () => {
 			},
 			async doctor(projectRoot) {
 				calls.push(`doctor:${projectRoot}`);
-				return { ok: true, conflicts: [], extensions: [], scanned: 0, truncated: false };
+				return { ok: true, conflicts: [], extensions: [], scanned: 0, truncated: false, serviceUnits: [] };
 			},
 			async updatesForProject(projectRoot) {
 				calls.push(`updatesForProject:${projectRoot}`);
@@ -939,6 +939,7 @@ describe("CLI", () => {
 			extensions: [],
 			scanned: 0,
 			truncated: false,
+			serviceUnits: [],
 		});
 		expect(JSON.parse((await cliRun(["updates", "--project", "/tmp/project", "--json"], d)).out).updates).toEqual([]);
 		expect(calls).toEqual([

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

@@ -0,0 +1,142 @@
+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 { checkServiceUnitPaths, parseExecStartTokens, type ServiceDoctorDeps } from "../src/adoption/service-doctor.ts";
+
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+function piHome(settingsPackages: unknown[]): string {
+	const root = mkdtempSync(join(tmpdir(), "packed-service-doctor-"));
+	roots.push(root);
+	writeFileSync(join(root, "settings.json"), JSON.stringify({ packages: settingsPackages }, null, 2));
+	return root;
+}
+
+/** A real installed package on disk, shaped so detectVehicleDaemonService recognizes it as a daemon (own bin + a real dependency on @danypops/vehicle-server). */
+function installDaemonPackage(home: string, name: string): string {
+	const dir = join(home, "npm", "node_modules", name);
+	mkdirSync(dir, { recursive: true });
+	writeFileSync(
+		join(dir, "package.json"),
+		JSON.stringify({ name, version: "1.0.0", bin: { [name]: "cli.ts" }, dependencies: { "@danypops/vehicle-server": "^0.7.0" } }, null, 2),
+	);
+	writeFileSync(join(dir, "cli.ts"), "// real entrypoint, present on disk\n");
+	return dir;
+}
+
+function fakeDeps(unitText: string | null): ServiceDoctorDeps {
+	return {
+		fileExists: () => unitText !== null,
+		readFile: () => unitText,
+		platform: "linux",
+	};
+}
+
+describe("parseExecStartTokens", () => {
+	it("parses shell-quoted tokens, unescaping the same characters shellQuote escapes", () => {
+		const unit = ['[Service]', 'ExecStart="/home/x/.bun/bin/bun" "/home/x/pkg/cli.ts" "serve"', ''].join("\n");
+		expect(parseExecStartTokens(unit)).toEqual(["/home/x/.bun/bin/bun", "/home/x/pkg/cli.ts", "serve"]);
+	});
+
+	it("unescapes a backslash-escaped quote/backslash/dollar/backtick inside a token", () => {
+		const unit = 'ExecStart="/bin/bun" "/weird \\"path\\" with \\\\ and \\$ and \\`"';
+		expect(parseExecStartTokens(unit)).toEqual(["/bin/bun", '/weird "path" with \\ and $ and `']);
+	});
+
+	it("returns undefined when there is no ExecStart line at all", () => {
+		expect(parseExecStartTokens("[Service]\nType=simple\n")).toBeUndefined();
+	});
+
+	it("returns undefined for an ExecStart line with no quoted tokens", () => {
+		expect(parseExecStartTokens("ExecStart=\n")).toBeUndefined();
+	});
+});
+
+describe("checkServiceUnitPaths", () => {
+	it("is silent on a non-linux platform without even reading installed packages", () => {
+		const home = piHome(["npm:whatever"]);
+		const report = checkServiceUnitPaths(home, undefined, { fileExists: () => true, readFile: () => "", platform: "darwin" });
+		expect(report).toEqual({ ok: true, diagnostics: [], checked: 0 });
+	});
+
+	it("skips a package that never resolves to a Vehicle-shaped daemon", () => {
+		const home = piHome(["npm:not-a-daemon"]);
+		const dir = join(home, "npm", "node_modules", "not-a-daemon");
+		mkdirSync(dir, { recursive: true });
+		writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "not-a-daemon", version: "1.0.0" }, null, 2));
+		const report = checkServiceUnitPaths(home, undefined, fakeDeps("ExecStart=\"/bin/true\"\n"));
+		expect(report).toEqual({ ok: true, diagnostics: [], checked: 0 });
+	});
+
+	it("skips a daemon-shaped package with no systemd unit currently installed", () => {
+		const home = piHome(["npm:fakedaemon"]);
+		installDaemonPackage(home, "fakedaemon");
+		const report = checkServiceUnitPaths(home, undefined, { fileExists: () => false, readFile: () => null, platform: "linux" });
+		expect(report).toEqual({ ok: true, diagnostics: [], checked: 0 });
+	});
+
+	it("reports clean when the installed unit's ExecStart paths all still exist", () => {
+		const home = piHome(["npm:fakedaemon"]);
+		const dir = installDaemonPackage(home, "fakedaemon");
+		const unit = `ExecStart="/bin/sh" "${join(dir, "cli.ts")}" "serve"\n`;
+		const report = checkServiceUnitPaths(home, undefined, fakeDeps(unit));
+		expect(report.checked).toBe(1);
+		expect(report.diagnostics).toEqual([]);
+		expect(report.ok).toBe(true);
+	});
+
+	it("flags SERVICE_EXEC_PATH_MISSING with the exact missing path when ExecStart references a deleted file", () => {
+		const home = piHome(["npm:fakedaemon"]);
+		installDaemonPackage(home, "fakedaemon");
+		const missing = join(tmpdir(), "packed-service-doctor-definitely-missing", "cli.ts");
+		const unit = `ExecStart="/bin/sh" "${missing}" "serve"\n`;
+		const report = checkServiceUnitPaths(home, undefined, fakeDeps(unit));
+		expect(report.ok).toBe(false);
+		expect(report.diagnostics).toEqual([
+			{
+				code: "SERVICE_EXEC_PATH_MISSING",
+				severity: "error",
+				package: "fakedaemon",
+				unitName: "fakedaemon",
+				message: expect.stringContaining(missing),
+			},
+		]);
+	});
+
+	it("never flags a bare subcommand argument (no path separator) as a missing path", () => {
+		const home = piHome(["npm:fakedaemon"]);
+		const dir = installDaemonPackage(home, "fakedaemon");
+		// "serve" alone would resolve relative to this process's own cwd and could
+		// spuriously not exist there -- must never be treated as a path to check.
+		const unit = `ExecStart="/bin/sh" "${join(dir, "cli.ts")}" "serve"\n`;
+		const report = checkServiceUnitPaths(home, undefined, fakeDeps(unit));
+		expect(report.diagnostics.some((d) => d.message.includes('"serve"'))).toBe(false);
+	});
+
+	it("degrades an unparseable ExecStart to a warning, never a false error", () => {
+		const home = piHome(["npm:fakedaemon"]);
+		installDaemonPackage(home, "fakedaemon");
+		const report = checkServiceUnitPaths(home, undefined, fakeDeps("[Service]\nType=simple\n"));
+		expect(report.ok).toBe(true);
+		expect(report.diagnostics).toEqual([
+			{
+				code: "SERVICE_EXEC_UNPARSEABLE",
+				severity: "warning",
+				package: "fakedaemon",
+				unitName: "fakedaemon",
+				message: expect.any(String),
+			},
+		]);
+	});
+
+	it("treats a raced fileExists=true/readFile=null as transient, not a finding", () => {
+		const home = piHome(["npm:fakedaemon"]);
+		installDaemonPackage(home, "fakedaemon");
+		const report = checkServiceUnitPaths(home, undefined, { fileExists: () => true, readFile: () => null, platform: "linux" });
+		expect(report).toEqual({ ok: true, diagnostics: [], checked: 1 });
+	});
+});