@danypops/pi-packed 0.19.9 → 0.19.10

package/service/test/core.test.ts

@@ -0,0 +1,181 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import type { Server } from "bun";
+import { buildSearchQuery, clampLimit } from "../src/packages/package.ts";
+import { HttpRegistry } from "../src/registry/registry.ts";
+import { TTLCache } from "../src/shared/cache.ts";
+import { envMs } from "../src/shared/state.ts";
+
+describe("buildSearchQuery", () => {
+	it("scopes to pi packages", () => {
+		expect(buildSearchQuery("lsp")).toBe("keywords:pi-package lsp");
+		expect(buildSearchQuery("  telegram  ")).toBe("keywords:pi-package telegram");
+		expect(buildSearchQuery("")).toBe("keywords:pi-package");
+		expect(buildSearchQuery("keywords:pi-package lsp")).toBe("keywords:pi-package lsp");
+	});
+});
+
+describe("clampLimit", () => {
+	it("defaults and clamps", () => {
+		expect(clampLimit(0, 10, 50)).toBe(10);
+		expect(clampLimit(999, 10, 50)).toBe(50);
+		expect(clampLimit(7, 10, 50)).toBe(7);
+	});
+});
+
+describe("TTLCache", () => {
+	it("stores and expires", async () => {
+		const c = new TTLCache(20); // ms
+		c.set("k", "v");
+		expect(c.get("k")).toBe("v");
+		await Bun.sleep(30);
+		expect(c.get("k")).toBeUndefined();
+	});
+});
+
+// Real HTTP adapter against a fake npm upstream (Bun.serve).
+describe("HttpRegistry", () => {
+	let server: Server<undefined>;
+	let registry: HttpRegistry;
+
+	beforeAll(() => {
+		server = Bun.serve({
+			port: 0,
+			fetch(req) {
+				const url = new URL(req.url);
+				if (url.pathname === "/-/v1/search") {
+					const from = Number(url.searchParams.get("from") ?? 0);
+					const size = Number(url.searchParams.get("size") ?? 10);
+					if (url.searchParams.get("text") !== "keywords:pi-package lsp") {
+						return Response.json({ error: "bad query" }, { status: 400 });
+					}
+					const all = [
+						{ name: "pi-lsp", version: "0.3.0", description: "LSP", date: "2026-06-01" },
+						{ name: "@narumitw/pi-lsp", version: "0.9.1", description: "another" },
+						{ name: "pi-lsp-lite", version: "1.0.0", description: "lite" },
+					];
+					const page = all.slice(from, from + size);
+					return Response.json({ total: all.length, objects: page.map((p) => ({ package: p })) });
+				}
+				if (url.pathname === "/downloads/point/last-week/pi-lsp") return Response.json({ downloads: 12 });
+				if (url.pathname === "/downloads/point/last-month/pi-lsp") return Response.json({ downloads: 34 });
+				if (url.pathname === "/pi-lsp/latest") {
+					return Response.json({
+						name: "pi-lsp",
+						version: "0.3.0",
+						description: "LSP for pi",
+						homepage: "https://example.com",
+						repository: { type: "git", url: "git+https://github.com/x/pi-lsp.git" },
+						license: "MIT",
+						keywords: ["pi-package", "lsp"],
+						pi: { extensions: ["./src/index.ts"] },
+						dist: {
+							unpackedSize: 12345,
+							integrity: "sha512-test",
+							attestations: { url: "https://registry.example/provenance", provenance: { predicateType: "slsa" } },
+						},
+					});
+				}
+				return new Response("nf", { status: 404 });
+			},
+		});
+		registry = new HttpRegistry(`http://127.0.0.1:${server.port}`, 2, 100, 1_000, `http://127.0.0.1:${server.port}`); // tiny page size
+	});
+	afterAll(() => server.stop(true));
+
+	it("search maps lean results", async () => {
+		const { results, total } = await registry.search("keywords:pi-package lsp", 2);
+		expect(total).toBe(3);
+		expect(results[0]).toMatchObject({ name: "pi-lsp", version: "0.3.0", packageEvidence: { shape: "keyword-only", verified: false } });
+	});
+
+	it("searchAll paginates", async () => {
+		const all = await registry.searchAll("keywords:pi-package lsp");
+		expect(all.map((p) => p.name)).toEqual(["pi-lsp", "@narumitw/pi-lsp", "pi-lsp-lite"]);
+	});
+
+	it("info maps latest version fields", async () => {
+		const info = await registry.info("pi-lsp");
+		expect(info).toMatchObject({
+			name: "pi-lsp",
+			version: "0.3.0",
+			description: "LSP for pi",
+			repository: "git+https://github.com/x/pi-lsp.git",
+			license: "MIT",
+			unpackedSize: 12345,
+			readmeAvailable: false,
+		});
+		expect(info.pi?.extensions).toBeDefined();
+		expect(info.packageEvidence).toMatchObject({ shape: "manifest", verified: false });
+		expect(info.publication).toEqual({
+			integrity: "sha512-test",
+			provenanceUrl: "https://registry.example/provenance",
+			trustedPublisher: "unknown",
+		});
+		expect(await registry.downloads("pi-lsp")).toMatchObject({ weekly: 12, monthly: 34 });
+	});
+
+	it("upstream errors surface", async () => {
+		expect(registry.info("missing-pkg")).rejects.toThrow(/404/);
+	});
+});
+
+describe("envMs (service lifecycle knob)", () => {
+	it("default when unset or garbage", () => {
+		delete process.env.PI_PACKED_TEST_MS;
+		expect(envMs("PI_PACKED_TEST_MS", 5000)).toBe(5000);
+		process.env.PI_PACKED_TEST_MS = "banana";
+		expect(envMs("PI_PACKED_TEST_MS", 5000)).toBe(5000);
+	});
+	it("seconds → ms when set", () => {
+		process.env.PI_PACKED_TEST_MS = "30";
+		expect(envMs("PI_PACKED_TEST_MS", 5000)).toBe(30_000);
+	});
+	it("zero disables (systemd owns the lifecycle)", () => {
+		process.env.PI_PACKED_TEST_MS = "0";
+		expect(envMs("PI_PACKED_TEST_MS", 5000)).toBe(0);
+	});
+});
+
+describe("upstream etiquette (429 handling)", () => {
+	it("retries on 429 honoring Retry-After, then succeeds", async () => {
+		let attempts = 0;
+		await using server = Bun.serve({
+			port: 0,
+			fetch() {
+				attempts++;
+				if (attempts <= 2) {
+					return new Response("slow down", { status: 429, headers: { "retry-after": "0" } });
+				}
+				return Response.json({ total: 0, objects: [] });
+			},
+		});
+		const reg = new HttpRegistry(`http://127.0.0.1:${server.port}`, 250, 0, 1);
+		const { total } = await reg.search("keywords:pi-package x", 10);
+		expect(total).toBe(0);
+		expect(attempts).toBe(3);
+	});
+
+	it("gives up after max attempts", async () => {
+		let attempts = 0;
+		await using server = Bun.serve({
+			port: 0,
+			fetch() {
+				attempts++;
+				return new Response("slow down", { status: 429, headers: { "retry-after": "0" } });
+			},
+		});
+		const reg = new HttpRegistry(`http://127.0.0.1:${server.port}`, 250, 0, 1);
+		expect(reg.search("keywords:pi-package x", 10)).rejects.toThrow(/429/);
+		expect(attempts).toBeGreaterThanOrEqual(3);
+	});
+
+	it("searchAll pauses between pages", async () => {
+		const reg = new HttpRegistry("http://unused", 250, 40);
+		const t0 = Date.now();
+		// monkey-patch searchPage to avoid network
+		reg.searchPage = async (_q: string, from: number) =>
+			from === 0 ? { results: [{ name: "a", version: "1" }], total: 2 } : { results: [{ name: "b", version: "1" }], total: 2 };
+		await reg.searchAll("keywords:pi-package");
+		expect(Date.now() - t0).toBeGreaterThanOrEqual(40);
+	});
+});

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

@@ -0,0 +1,181 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { AuthenticatedRpcClient } from "@danypops/vehicle-client/rpc-client";
+import { readDaemonHandle } from "@danypops/vehicle-server/paths";
+import { connectPackageDaemon } from "../src/daemon/client.ts";
+import { startPackedDaemon } from "../src/daemon/daemon.ts";
+import { createApp, type OperationInputs, type OperationName, type OperationOutputs } from "../src/daemon/service.ts";
+import type { Installer, Registry } from "../src/packages/package.ts";
+import { migrateLegacyPackedState, resolvePackedPaths } from "../src/shared/paths.ts";
+
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+function tempRoot(name: string): string {
+	const root = join(tmpdir(), `${name}-${crypto.randomUUID()}`);
+	mkdirSync(root, { recursive: true });
+	roots.push(root);
+	return root;
+}
+
+function testPaths(root: string) {
+	return resolvePackedPaths({
+		env: {
+			XDG_DATA_HOME: join(root, "data"),
+			XDG_STATE_HOME: join(root, "state"),
+			XDG_RUNTIME_DIR: join(root, "runtime"),
+			XDG_CONFIG_HOME: join(root, "config"),
+		},
+		home: root,
+		uid: 1000,
+	});
+}
+
+const registry: Registry = {
+	async search(_query, _limit) {
+		return { total: 1, results: [{ name: "pi-test", version: "1.0.0" }] };
+	},
+	async searchPage(_query, _from, _size) {
+		return { total: 1, results: [{ name: "pi-test", version: "1.0.0" }] };
+	},
+	async searchAll() {
+		return [{ name: "pi-test", version: "1.0.0" }];
+	},
+	async info(name) {
+		return { name, version: "1.0.0" };
+	},
+};
+
+const installer: Installer = {
+	async install(source) {
+		return `installed ${source}`;
+	},
+	async remove(source) {
+		return `removed ${source}`;
+	},
+	async update(source) {
+		return { output: `updated ${source}`, reloadRequired: true, alreadyUpToDate: false, pinned: false };
+	},
+};
+
+describe("daemon-kit migration", () => {
+	it("resolves XDG-split paths and keeps PI_PACKED_HOME as an explicit compatibility override", () => {
+		const root = tempRoot("packed-paths");
+		const paths = testPaths(root);
+		expect(paths.database).toBe(join(root, "data", "pi-packed", "packed.db"));
+		expect(paths.token).toBe(join(root, "state", "pi-packed", "token"));
+		expect(paths.handle).toBe(join(root, "runtime", "pi-packed", "handle.json"));
+		expect(paths.stateDirectory).toBe(join(root, "state", "pi-packed"));
+
+		const override = join(root, "override");
+		const compatible = resolvePackedPaths({ env: { PI_PACKED_HOME: override }, home: root, uid: 1000 });
+		expect(compatible.database).toBe(join(override, "packed.db"));
+		expect(compatible.token).toBe(join(override, "token"));
+		expect(compatible.handle).toBe(join(override, "handle.json"));
+		expect(compatible.stateDirectory).toBe(override);
+	});
+
+	it("copies legacy state into missing XDG destinations without overwriting migrated files", () => {
+		const root = tempRoot("packed-legacy");
+		const legacy = join(root, "legacy");
+		mkdirSync(legacy, { recursive: true });
+		writeFileSync(join(legacy, "packed.db"), "legacy-db", { mode: 0o600 });
+		writeFileSync(join(legacy, "packed.db-wal"), "legacy-wal", { mode: 0o600 });
+		writeFileSync(join(legacy, "packed.db-shm"), "legacy-shm", { mode: 0o600 });
+		writeFileSync(join(legacy, "token"), `${"a".repeat(64)}\n`, { mode: 0o600 });
+		writeFileSync(join(legacy, "security.json"), '{"mutationApproval":"never"}\n', { mode: 0o600 });
+		const paths = testPaths(root);
+
+		migrateLegacyPackedState(paths, legacy);
+		expect(readFileSync(paths.database, "utf8")).toBe("legacy-db");
+		expect(readFileSync(`${paths.database}-wal`, "utf8")).toBe("legacy-wal");
+		expect(readFileSync(`${paths.database}-shm`, "utf8")).toBe("legacy-shm");
+		expect(readFileSync(paths.token, "utf8").trim()).toBe("a".repeat(64));
+		expect(readFileSync(join(paths.stateDirectory, "security.json"), "utf8")).toContain("never");
+		expect(statSync(paths.token).mode & 0o777).toBe(0o600);
+
+		writeFileSync(paths.database, "new-db");
+		migrateLegacyPackedState(paths, legacy);
+		expect(readFileSync(paths.database, "utf8")).toBe("new-db");
+	});
+
+	it("does not carry the legacy 128-bit bearer token into daemon-kit state", () => {
+		const root = tempRoot("packed-token-rotation");
+		const legacy = join(root, "legacy");
+		mkdirSync(legacy, { recursive: true });
+		writeFileSync(join(legacy, "token"), `${"b".repeat(32)}\n`, { mode: 0o600 });
+		const paths = testPaths(root);
+		migrateLegacyPackedState(paths, legacy);
+		expect(existsSync(paths.token)).toBe(false);
+	});
+
+	it("serves the typed operation registry while preserving authenticated REST routes", async () => {
+		const root = tempRoot("packed-rpc");
+		const app = createApp({ reg: registry, inst: installer, token: "test-token", stateDir: root, dataDir: root, piHome: root });
+		const client = new AuthenticatedRpcClient<OperationName, OperationInputs, OperationOutputs>("http://packed.test", "test-token", {
+			label: "Packed",
+			transport: (request) => app.fetch(request),
+		});
+
+		expect(await client.operations()).toEqual([
+			"package.search",
+			"package.info",
+			"package.installed",
+			"package.catalog",
+			"package.catalog.sync",
+			"package.index",
+			"package.index.build",
+			"package.updates",
+			"package.check",
+			"package.pack",
+			"package.score",
+			"setup.export",
+			"setup.update",
+			"setup.plan",
+			"setup.apply",
+			"package.security.get",
+			"package.security.set",
+			"package.install",
+			"package.install_service",
+			"package.restart_service",
+			"package.remove",
+			"package.update",
+			"resources.list",
+			"resources.toggle",
+			"pi.status",
+			"advisories.scan",
+			"doctor.run",
+			"package.updates.project",
+		]);
+		expect(await client.call("package.search", { query: "test", limit: 10, offline: false })).toMatchObject({ total: 1 });
+		expect(await client.call("package.info", { name: "pi-test" })).toEqual({ name: "pi-test", version: "1.0.0" });
+		expect(await client.call("package.catalog.sync", {})).toEqual({ synced: 1 });
+		expect((await client.call("package.catalog", {})).packages.map(({ name, version }) => ({ name, version }))).toEqual([
+			{ name: "pi-test", version: "1.0.0" },
+		]);
+
+		const rest = await app.fetch(new Request("http://packed.test/info?name=pi-test", { headers: { authorization: "Bearer test-token" } }));
+		expect(rest.status).toBe(200);
+		expect(await rest.json()).toEqual({ name: "pi-test", version: "1.0.0" });
+	});
+
+	it("starts and stops through daemon-kit with an atomic authenticated handle", async () => {
+		const root = tempRoot("packed-daemon");
+		const paths = testPaths(root);
+		const running = await startPackedDaemon({ paths, reg: registry, inst: installer, piHome: root, maintenanceTasks: [] });
+		try {
+			const handle = readDaemonHandle(paths.handle);
+			expect(handle).toMatchObject({ host: "127.0.0.1", port: running.port, pid: process.pid });
+			expect(existsSync(paths.token)).toBe(true);
+			expect(readFileSync(paths.token, "utf8").trim()).toMatch(/^[a-f0-9]{64}$/);
+			expect(await (await connectPackageDaemon(paths)).info("pi-test")).toEqual({ name: "pi-test", version: "1.0.0" });
+		} finally {
+			await running.stop();
+		}
+		expect(readDaemonHandle(paths.handle)).toBeNull();
+	});
+});

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

@@ -0,0 +1,238 @@
+import { describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ServiceInstallDeps } from "@danypops/vehicle-server/service";
+import { detectVehicleDaemonService, resolveDaemonServiceSpec, restartUserService } from "../src/daemon/daemon-service.ts";
+
+function fakePiHome(): string {
+	return mkdtempSync(join(tmpdir(), "packed-daemon-service-"));
+}
+
+function writePackage(piHome: string, name: string, manifest: unknown): void {
+	const dir = join(piHome, "npm", "node_modules", name);
+	mkdirSync(dir, { recursive: true });
+	writeFileSync(
+		join(dir, "package.json"),
+		JSON.stringify({ name, version: "1.0.0", ...(manifest ? { packed: { daemonService: manifest } } : {}) }),
+	);
+}
+
+function writeRawPackage(dir: string, pkg: Record<string, unknown>): void {
+	mkdirSync(dir, { recursive: true });
+	writeFileSync(join(dir, "package.json"), JSON.stringify(pkg));
+}
+
+describe("resolveDaemonServiceSpec", () => {
+	it("builds a ServiceSpec from a package's packed.daemonService manifest", () => {
+		const piHome = fakePiHome();
+		writePackage(piHome, "@danypops/web-spider-daemon", { binPath: "dist/cli.js", args: ["serve"] });
+
+		const result = resolveDaemonServiceSpec(piHome, "npm:@danypops/web-spider-daemon");
+		expect(result).toEqual({
+			ok: true,
+			spec: {
+				name: "web-spider-daemon",
+				displayName: undefined,
+				binPath: join(piHome, "npm", "node_modules", "@danypops/web-spider-daemon", "dist/cli.js"),
+				args: ["serve"],
+				descriptorPath: expect.stringContaining("web-spider-daemon") as unknown as string,
+			},
+		});
+	});
+
+	it("honors an explicit name/displayName override instead of deriving one from the npm package name", () => {
+		const piHome = fakePiHome();
+		writePackage(piHome, "@danypops/web-spider-daemon", { binPath: "dist/cli.js", name: "web-spider", displayName: "Web Spider" });
+
+		const result = resolveDaemonServiceSpec(piHome, "npm:@danypops/web-spider-daemon");
+		expect(result.ok).toBe(true);
+		if (!result.ok) throw new Error("expected ok");
+		expect(result.spec.name).toBe("web-spider");
+		expect(result.spec.displayName).toBe("Web Spider");
+	});
+
+	it("fails closed for a package that declares no daemonService manifest", () => {
+		const piHome = fakePiHome();
+		writePackage(piHome, "some-pkg", undefined);
+
+		const result = resolveDaemonServiceSpec(piHome, "npm:some-pkg");
+		expect(result).toEqual({
+			ok: false,
+			notADaemon: true,
+			reason: expect.stringContaining("does not declare a packed.daemonService manifest") as unknown as string,
+		});
+	});
+
+	it("fails closed for a package that was never actually installed", () => {
+		const piHome = fakePiHome();
+		const result = resolveDaemonServiceSpec(piHome, "npm:never-installed");
+		expect(result.ok).toBe(false);
+	});
+
+	it("fails closed for a non-npm source -- git:/local resolution isn't supported yet", () => {
+		const piHome = fakePiHome();
+		const result = resolveDaemonServiceSpec(piHome, "git:github.com/u/r@v1");
+		expect(result).toEqual({ ok: false, reason: expect.stringContaining("only supports npm:") as unknown as string });
+	});
+
+	it("falls back to detection when the package itself is the daemon (bin + real vehicle-server dependency, no manifest)", () => {
+		const piHome = fakePiHome();
+		const dir = join(piHome, "npm", "node_modules", "@danypops/papyrus");
+		writeRawPackage(dir, {
+			name: "@danypops/papyrus",
+			version: "1.0.0",
+			bin: { papyrus: "src/cli.ts" },
+			dependencies: { "@danypops/vehicle-server": "^0.1.0" },
+		});
+
+		const result = resolveDaemonServiceSpec(piHome, "npm:@danypops/papyrus");
+		expect(result).toEqual({
+			ok: true,
+			spec: {
+				name: "papyrus",
+				displayName: undefined,
+				binPath: join(dir, "src/cli.ts"),
+				args: ["serve"],
+				descriptorPath: expect.stringContaining("papyrus") as unknown as string,
+			},
+		});
+	});
+
+	it("falls back to detection one level into a real dependency -- a Pi extension with no daemon of its own", () => {
+		const piHome = fakePiHome();
+		const extDir = join(piHome, "npm", "node_modules", "@danypops/pi-papyrus");
+		writeRawPackage(extDir, { name: "@danypops/pi-papyrus", version: "1.0.0", dependencies: { "@danypops/papyrus": "^0.38.0" } });
+		const depDir = join(extDir, "node_modules", "@danypops/papyrus");
+		writeRawPackage(depDir, {
+			name: "@danypops/papyrus",
+			version: "0.38.0",
+			bin: { papyrus: "src/cli.ts" },
+			dependencies: { "@danypops/vehicle-server": "^0.1.0" },
+		});
+
+		const result = resolveDaemonServiceSpec(piHome, "npm:@danypops/pi-papyrus");
+		expect(result.ok).toBe(true);
+		if (!result.ok) throw new Error("expected ok");
+		expect(result.spec.binPath).toBe(join(depDir, "src/cli.ts"));
+		expect(result.spec.args).toEqual(["serve"]);
+		expect(result.spec.name).toBe("papyrus");
+	});
+
+	it("falls back to detection via npm's hoisted top-level node_modules, not just a nested one -- the real on-disk layout for a flat npm install", () => {
+		const piHome = fakePiHome();
+		const extDir = join(piHome, "npm", "node_modules", "@danypops/pi-papyrus");
+		writeRawPackage(extDir, { name: "@danypops/pi-papyrus", version: "1.0.0", dependencies: { "@danypops/papyrus": "^0.38.0" } });
+		// Hoisted to the SAME top-level node_modules as pi-papyrus itself, not nested under it --
+		// confirmed live as the real layout npm produces for a flat single-root install (Packed's
+		// own piHome/npm install target), as opposed to the nested-dependency layout the prior test
+		// exercises. Both are real, both must resolve.
+		const depDir = join(piHome, "npm", "node_modules", "@danypops/papyrus");
+		writeRawPackage(depDir, {
+			name: "@danypops/papyrus",
+			version: "0.38.0",
+			bin: { papyrus: "src/cli.ts" },
+			dependencies: { "@danypops/vehicle-server": "^0.1.0" },
+		});
+
+		const result = resolveDaemonServiceSpec(piHome, "npm:@danypops/pi-papyrus");
+		expect(result.ok).toBe(true);
+		if (!result.ok) throw new Error("expected ok");
+		expect(result.spec.binPath).toBe(join(depDir, "src/cli.ts"));
+		expect(result.spec.args).toEqual(["serve"]);
+		expect(result.spec.name).toBe("papyrus");
+	});
+
+	it("also detects the legacy @danypops/daemon-kit dependency name, not just vehicle-server", () => {
+		const piHome = fakePiHome();
+		const dir = join(piHome, "npm", "node_modules", "@danypops/web-spider-daemon");
+		writeRawPackage(dir, {
+			name: "@danypops/web-spider-daemon",
+			version: "1.0.0",
+			bin: { "web-spider": "src/cli.ts" },
+			dependencies: { "@danypops/daemon-kit": "^0.18.0" },
+		});
+
+		const result = resolveDaemonServiceSpec(piHome, "npm:@danypops/web-spider-daemon");
+		expect(result.ok).toBe(true);
+		if (!result.ok) throw new Error("expected ok");
+		expect(result.spec.binPath).toBe(join(dir, "src/cli.ts"));
+	});
+
+	it("an explicit manifest still wins over detection when both are present", () => {
+		const piHome = fakePiHome();
+		const dir = join(piHome, "npm", "node_modules", "@danypops/papyrus");
+		writeRawPackage(dir, {
+			name: "@danypops/papyrus",
+			version: "1.0.0",
+			bin: { papyrus: "src/cli.ts" },
+			dependencies: { "@danypops/vehicle-server": "^0.1.0" },
+			packed: { daemonService: { binPath: "dist/cli.js", args: ["serve", "--custom"], name: "papyrus-custom" } },
+		});
+
+		const result = resolveDaemonServiceSpec(piHome, "npm:@danypops/papyrus");
+		expect(result.ok).toBe(true);
+		if (!result.ok) throw new Error("expected ok");
+		expect(result.spec.binPath).toBe(join(dir, "dist/cli.js"));
+		expect(result.spec.args).toEqual(["serve", "--custom"]);
+		expect(result.spec.name).toBe("papyrus-custom");
+	});
+
+	it("detects nothing for a package with a bin but no real vehicle-server/daemon-kit dependency", () => {
+		const piHome = fakePiHome();
+		const dir = join(piHome, "npm", "node_modules", "some-cli");
+		writeRawPackage(dir, { name: "some-cli", version: "1.0.0", bin: { "some-cli": "src/cli.ts" }, dependencies: { commander: "^12.0.0" } });
+
+		expect(detectVehicleDaemonService(dir, "some-cli")).toBeUndefined();
+		const result = resolveDaemonServiceSpec(piHome, "npm:some-cli");
+		expect(result.ok).toBe(false);
+	});
+});
+
+function fakeInstallDeps(over: Partial<ServiceInstallDeps> = {}): ServiceInstallDeps {
+	return {
+		platform: "linux",
+		writeFile: () => {},
+		readFile: () => null,
+		removeFile: () => {},
+		fileExists: () => false,
+		mkdirp: () => {},
+		runCommand: () => ({ ok: true, output: "" }),
+		which: () => true,
+		...over,
+	};
+}
+
+describe("restartUserService", () => {
+	const spec = { name: "probe", binPath: "/opt/probe/cli.js", descriptorPath: "/home/user/.config/systemd/user/probe.service" };
+
+	it("restarts via systemctl --user restart, using the descriptor's basename as the unit name", () => {
+		const calls: Array<{ command: string; args: string[] }> = [];
+		const deps = fakeInstallDeps({
+			runCommand: (command, args) => {
+				calls.push({ command, args });
+				return { ok: true, output: "" };
+			},
+		});
+
+		const result = restartUserService(spec, deps);
+		expect(result).toEqual({ restarted: true });
+		expect(calls).toEqual([{ command: "systemctl", args: ["--user", "restart", "probe.service"] }]);
+	});
+
+	it("reports a real systemctl failure without throwing", () => {
+		const deps = fakeInstallDeps({ runCommand: () => ({ ok: false, output: "Unit probe.service not loaded" }) });
+
+		const result = restartUserService(spec, deps);
+		expect(result.restarted).toBe(false);
+		expect(result.reason).toContain("Unit probe.service not loaded");
+	});
+
+	it("refuses on a platform with no supported restart mechanism, rather than guessing at one", () => {
+		const deps = fakeInstallDeps({ platform: "darwin" });
+
+		const result = restartUserService(spec, deps);
+		expect(result.restarted).toBe(false);
+		expect(result.reason).toContain('platform "darwin"');
+	});
+});