@danypops/pi-packed 0.19.7 → 0.19.10

package/service/test/db.test.ts

@@ -0,0 +1,178 @@
+import { describe, expect, it } from "bun:test";
+import { existsSync, mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { syncCatalog } from "../src/packages/catalog.ts";
+import { catalogList, dbPath, getSyncMeta, openDb, replaceAll, searchLocal } from "../src/packages/db.ts";
+import type { Pkg, PkgInfo, Registry, SearchPage } from "../src/packages/package.ts";
+import { HttpRegistry } from "../src/registry/registry.ts";
+
+const PKGS = [
+	{ name: "pi-lsp", version: "0.18.0", description: "LSP tools for pi" },
+	{ name: "@llblab/pi-telegram", version: "0.23.1", description: "Telegram runtime adapter" },
+	{ name: "pi-lsp-lite", version: "1.0.0", description: "lightweight LSP" },
+];
+
+describe("db (local registry index)", () => {
+	it("creates schema and replaces the catalog atomically", () => {
+		const db = openDb(":memory:");
+		replaceAll(db, PKGS, "test-source");
+		expect(catalogList(db)).toHaveLength(3);
+		expect(catalogList(db)[0]?.packageEvidence).toMatchObject({ shape: "keyword-only", verified: false });
+		// Second sync replaces, not appends
+		replaceAll(db, [PKGS[0]!], "test-source");
+		expect(catalogList(db)).toHaveLength(1);
+		db.close();
+	});
+
+	it("roundtrips verified Pi shape and publication evidence", () => {
+		const db = openDb(":memory:");
+		replaceAll(
+			db,
+			[
+				{
+					name: "pi-verified",
+					version: "1",
+					packageEvidence: { shape: "conventional", verified: true, evidence: ["extensions"] },
+					publication: { provenanceUrl: "https://registry.example/attestation", trustedPublisher: "verified" },
+				},
+			],
+			"snapshot",
+		);
+		expect(catalogList(db)[0]).toMatchObject({
+			packageEvidence: { shape: "conventional", verified: true, evidence: ["extensions"] },
+			publication: { provenanceUrl: "https://registry.example/attestation", trustedPublisher: "verified" },
+		});
+		db.close();
+	});
+
+	it("searchLocal: FTS with AND semantics, scoped names, ranking", () => {
+		const db = openDb(":memory:");
+		replaceAll(db, PKGS, "test");
+		expect(searchLocal(db, "lsp").map((p) => p.name)).toContain("pi-lsp");
+		const and = searchLocal(db, "lsp lightweight");
+		expect(and.map((p) => p.name)).toEqual(["pi-lsp-lite"]);
+		expect(searchLocal(db, "telegram").map((p) => p.name)).toEqual(["@llblab/pi-telegram"]);
+		expect(searchLocal(db, "nonexistent")).toEqual([]);
+		db.close();
+	});
+
+	it("ranks verified Pi-shaped packages ahead of keyword-only candidates", () => {
+		const db = openDb(":memory:");
+		replaceAll(
+			db,
+			[
+				{ name: "candidate", version: "1", description: "shared package" },
+				{
+					name: "verified",
+					version: "1",
+					description: "shared package",
+					packageEvidence: { shape: "manifest", verified: true, evidence: ["pi.extensions"] },
+				},
+			],
+			"snapshot",
+		);
+		expect(searchLocal(db, "shared").map((item) => item.name)).toEqual(["verified", "candidate"]);
+		db.close();
+	});
+
+	it("searchLocal survives FTS-hostile input (LIKE fallback)", () => {
+		const db = openDb(":memory:");
+		replaceAll(db, PKGS, "test");
+		expect(() => searchLocal(db, 'lsp "broken')).not.toThrow();
+		expect(searchLocal(db, "lsp*")).toContainEqual(expect.objectContaining({ name: "pi-lsp" }));
+		db.close();
+	});
+
+	it("sync meta carries source, time, count, and a payload checksum", () => {
+		const db = openDb(":memory:");
+		replaceAll(db, PKGS, "npm");
+		const meta = getSyncMeta(db)!;
+		expect(meta.source).toBe("npm");
+		expect(meta.packageCount).toBe(3);
+		expect(meta.fetchedAt).toBeTruthy();
+		expect(meta.sha256).toMatch(/^[0-9a-f]{64}$/);
+		db.close();
+	});
+
+	it("dbPath lives in the state dir", () => {
+		expect(dbPath("/tmp/x")).toBe(join("/tmp/x", "packed.db"));
+	});
+});
+
+// The sync pipeline: paginated upstream → SQLite mirror (apt update analog).
+class PagedRegistry implements Registry {
+	constructor(
+		private pages: Record<number, Pkg[]>,
+		private total: number,
+	) {}
+	async search(): Promise<SearchPage> {
+		return { results: [], total: 0 };
+	}
+	async searchPage(_q: string, from: number, _size?: number): Promise<SearchPage> {
+		return { results: this.pages[from] ?? [], total: this.total };
+	}
+	async searchAll(q: string): Promise<Pkg[]> {
+		const out: Pkg[] = [];
+		let from = 0;
+		for (;;) {
+			const { results, total } = await this.searchPage(q, from, 0);
+			out.push(...results);
+			from += results.length;
+			if (results.length === 0 || from >= total) return out;
+		}
+	}
+	async info(name: string): Promise<PkgInfo> {
+		return { name, version: "1" };
+	}
+}
+
+describe("syncCatalog → SQLite", () => {
+	it("accumulates pages into the DB and records sync meta", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "packed-"));
+		const reg = new PagedRegistry({ 0: PKGS.slice(0, 2), 2: PKGS.slice(2) }, 3);
+		expect(await syncCatalog(reg, dir)).toBe(3);
+		expect(existsSync(dbPath(dir))).toBe(true);
+
+		const db = openDb(dbPath(dir));
+		expect(catalogList(db).map((p) => p.name)).toEqual([...PKGS.map((p) => p.name)].sort());
+		expect(getSyncMeta(db)!.packageCount).toBe(3);
+		db.close();
+	});
+});
+
+describe("unstable upstream pagination", () => {
+	it("replaceAll tolerates duplicate names (INSERT OR REPLACE)", () => {
+		const db = openDb(":memory:");
+		const dupes = [
+			{ name: "pi-lsp", version: "0.18.0" },
+			{ name: "a", version: "1" },
+			{ name: "pi-lsp", version: "0.19.0" }, // shifted onto a second page
+		];
+		expect(() => replaceAll(db, dupes, "test")).not.toThrow();
+		expect(catalogList(db)).toHaveLength(2);
+		db.close();
+	});
+
+	it("searchAll dedupes packages that shift across pages", async () => {
+		const reg = new HttpRegistry("http://unused", 250, 0, 1);
+		reg.searchPage = async (_q: string, from: number) =>
+			from === 0
+				? {
+						results: [
+							{ name: "a", version: "1" },
+							{ name: "b", version: "1" },
+						],
+						total: 3,
+					}
+				: {
+						results: [
+							{ name: "b", version: "1" },
+							{ name: "c", version: "1" },
+						],
+						total: 3,
+					};
+		const all = await reg.searchAll("keywords:pi-package");
+		expect(all.map((p: Pkg) => p.name)).toEqual(["a", "b", "c"]);
+	});
+});

package/service/test/doctor.test.ts

@@ -0,0 +1,234 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { AuthenticatedRpcClient } from "@danypops/vehicle-client/rpc-client";
+import { runDoctor } from "../src/adoption/doctor.ts";
+import { createApp, type OperationInputs, type OperationName, type OperationOutputs } from "../src/daemon/service.ts";
+import type { Installer, PkgInfo, Registry, SearchPage } from "../src/packages/package.ts";
+
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+// Same sandbox-availability probe as smoke.test.ts: binary presence alone
+// doesn't prove bwrap actually works under this host's user namespaces.
+function bwrapUsable(): boolean {
+	if (!existsSync("/usr/bin/bwrap")) return false;
+	const probe = spawnSync("/usr/bin/bwrap", ["--ro-bind", "/", "/", "--unshare-all", "--", "/bin/true"], { timeout: 5_000 });
+	return probe.status === 0;
+}
+const describeIfSandboxed = bwrapUsable() ? describe : describe.skip;
+
+function piHome(settingsPackages: unknown[]): string {
+	const root = mkdtempSync(join(tmpdir(), "packed-doctor-"));
+	roots.push(root);
+	writeFileSync(join(root, "settings.json"), JSON.stringify({ packages: settingsPackages }, null, 2));
+	return root;
+}
+
+function installNpmPackage(home: string, name: string, pi: Record<string, unknown>, files: Record<string, string>): void {
+	const dir = join(home, "npm", "node_modules", name);
+	mkdirSync(dir, { recursive: true });
+	writeFileSync(join(dir, "package.json"), JSON.stringify({ name, version: "1.0.0", pi }, null, 2));
+	for (const [path, content] of Object.entries(files)) {
+		mkdirSync(join(dir, path, ".."), { recursive: true });
+		writeFileSync(join(dir, path), content);
+	}
+}
+
+describeIfSandboxed("runDoctor", () => {
+	it("reports no conflicts when every package's tools are distinct", async () => {
+		const home = piHome(["npm:pi-a", "npm:pi-b"]);
+		installNpmPackage(
+			home,
+			"pi-a",
+			{ extensions: ["extension/index.ts"] },
+			{
+				"extension/index.ts": 'export default function (pi: any) { pi.registerTool({ name: "alpha" }); }',
+			},
+		);
+		installNpmPackage(
+			home,
+			"pi-b",
+			{ extensions: ["extension/index.ts"] },
+			{
+				"extension/index.ts": 'export default function (pi: any) { pi.registerTool({ name: "beta" }); }',
+			},
+		);
+
+		const report = await runDoctor(home);
+
+		expect(report.ok).toBe(true);
+		expect(report.conflicts).toEqual([]);
+		expect(report.scanned).toBe(2);
+	});
+
+	it("reproduces the real jittor incident: a stale project-scoped package re-registering a globally-loaded package's tool names", async () => {
+		const home = piHome(["npm:pi-papyrus"]);
+		installNpmPackage(
+			home,
+			"pi-papyrus",
+			{ extensions: ["extension/index.ts"] },
+			{
+				"extension/index.ts":
+					'export default function (pi: any) { pi.registerTool({ name: "tasks" }); pi.registerTool({ name: "docs" }); }',
+			},
+		);
+		const projectRoot = mkdtempSync(join(tmpdir(), "packed-doctor-project-"));
+		roots.push(projectRoot);
+		const projectHome = join(projectRoot, ".pi");
+		mkdirSync(projectHome, { recursive: true });
+		writeFileSync(join(projectHome, "settings.json"), JSON.stringify({ packages: ["npm:papyrus"] }));
+		installNpmPackage(
+			projectHome,
+			"papyrus",
+			{ extensions: ["extension/index.ts"] },
+			{
+				"extension/index.ts": 'export default function (pi: any) { pi.registerTool({ name: "tasks" }); }',
+			},
+		);
+
+		const report = await runDoctor(home, projectRoot);
+
+		expect(report.ok).toBe(false);
+		expect(report.conflicts).toHaveLength(1);
+		const conflict = report.conflicts[0]!;
+		expect(conflict).toMatchObject({ kind: "tool", name: "tasks" });
+		expect(conflict.claimants).toHaveLength(2);
+		expect(conflict.claimants.map((c) => c.scope).sort()).toEqual(["global", "project"]);
+		expect(conflict.claimants.map((c) => c.name).sort()).toEqual(["papyrus", "pi-papyrus"]);
+	});
+
+	it("never treats a disabled extension as a claimant", async () => {
+		const home = piHome([{ source: "npm:pi-a", extensions: [] }, "npm:pi-b"]);
+		installNpmPackage(
+			home,
+			"pi-a",
+			{ extensions: ["extension/index.ts"] },
+			{
+				"extension/index.ts": 'export default function (pi: any) { pi.registerTool({ name: "shared" }); }',
+			},
+		);
+		installNpmPackage(
+			home,
+			"pi-b",
+			{ extensions: ["extension/index.ts"] },
+			{
+				"extension/index.ts": 'export default function (pi: any) { pi.registerTool({ name: "shared" }); }',
+			},
+		);
+
+		const report = await runDoctor(home);
+
+		expect(report.ok).toBe(true);
+		expect(report.conflicts).toEqual([]);
+	});
+
+	it("surfaces a genuinely crashing extension as a non-ok result without treating it as a conflict", async () => {
+		const home = piHome(["npm:pi-broken"]);
+		installNpmPackage(
+			home,
+			"pi-broken",
+			{ extensions: ["extension/index.ts"] },
+			{
+				"extension/index.ts": 'export default function () { throw new Error("boom"); }',
+			},
+		);
+
+		const report = await runDoctor(home);
+
+		expect(report.ok).toBe(false);
+		expect(report.conflicts).toEqual([]);
+		expect(report.extensions).toHaveLength(1);
+		expect(report.extensions[0]?.status).toBe("crash");
+	});
+
+	it("is unaffected by a missing project settings file", async () => {
+		const home = piHome(["npm:pi-a"]);
+		installNpmPackage(
+			home,
+			"pi-a",
+			{ extensions: ["extension/index.ts"] },
+			{
+				"extension/index.ts": 'export default function (pi: any) { pi.registerTool({ name: "alpha" }); }',
+			},
+		);
+		const projectRoot = mkdtempSync(join(tmpdir(), "packed-doctor-project-"));
+		roots.push(projectRoot);
+
+		const report = await runDoctor(home, projectRoot);
+
+		expect(report.ok).toBe(true);
+		expect(report.scanned).toBe(1);
+	});
+});
+
+class NoopRegistry implements Registry {
+	async search(): Promise<SearchPage> {
+		return { results: [], total: 0 };
+	}
+	async searchPage(): Promise<SearchPage> {
+		return { results: [], total: 0 };
+	}
+	async searchAll() {
+		return [];
+	}
+	async info(name: string): Promise<PkgInfo> {
+		return { name, version: "1.0.0" };
+	}
+}
+
+class NoopInstaller implements Installer {
+	async install() {
+		return "ok";
+	}
+	async remove() {
+		return "ok";
+	}
+	async update() {
+		return { output: "ok", reloadRequired: false, alreadyUpToDate: true, pinned: false };
+	}
+}
+
+describeIfSandboxed("doctor.run (daemon RPC wiring)", () => {
+	it("reports the same conflict through the authenticated RPC operation as the pure domain function", async () => {
+		const home = piHome(["npm:pi-a", "npm:pi-b"]);
+		installNpmPackage(
+			home,
+			"pi-a",
+			{ extensions: ["extension/index.ts"] },
+			{
+				"extension/index.ts": 'export default function (pi: any) { pi.registerTool({ name: "shared" }); }',
+			},
+		);
+		installNpmPackage(
+			home,
+			"pi-b",
+			{ extensions: ["extension/index.ts"] },
+			{
+				"extension/index.ts": 'export default function (pi: any) { pi.registerTool({ name: "shared" }); }',
+			},
+		);
+		const app = createApp({
+			reg: new NoopRegistry(),
+			inst: new NoopInstaller(),
+			token: "test-token",
+			stateDir: mkdtempSync(join(tmpdir(), "packed-doctor-state-")),
+			dataDir: mkdtempSync(join(tmpdir(), "packed-doctor-data-")),
+			piHome: home,
+		});
+		const client = new AuthenticatedRpcClient<OperationName, OperationInputs, OperationOutputs>("http://packed.test", "test-token", {
+			label: "Packed",
+			transport: (request) => app.fetch(request),
+		});
+
+		const result = await client.call("doctor.run", {});
+
+		expect(result).toEqual(await runDoctor(home));
+		expect(result.ok).toBe(false);
+		expect(result.conflicts).toHaveLength(1);
+	});
+});