@blackbelt-technology/pi-agent-dashboard 0.2.9 → 0.4.0

package/packages/server/src/__tests__/pi-core-checker.test.ts

@@ -0,0 +1,195 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import { PiCoreChecker, CORE_PACKAGE_NAMES, _internal } from "../pi-core-checker.js";
+
+describe("PiCoreChecker._internal.looksLikePiEcosystem", () => {
+	it("matches known core packages", () => {
+		for (const name of CORE_PACKAGE_NAMES) {
+			expect(_internal.looksLikePiEcosystem(name)).toBe(true);
+		}
+	});
+
+	it("matches bare pi- packages", () => {
+		expect(_internal.looksLikePiEcosystem("pi-web-access")).toBe(true);
+		expect(_internal.looksLikePiEcosystem("pi-agent-browser")).toBe(true);
+	});
+
+	it("matches scoped pi- packages", () => {
+		expect(_internal.looksLikePiEcosystem("@tintinweb/pi-subagents")).toBe(true);
+		expect(_internal.looksLikePiEcosystem("@benvargas/pi-claude-code-use")).toBe(true);
+	});
+
+	it("rejects non-pi packages", () => {
+		expect(_internal.looksLikePiEcosystem("react")).toBe(false);
+		expect(_internal.looksLikePiEcosystem("@types/node")).toBe(false);
+		expect(_internal.looksLikePiEcosystem("piano")).toBe(false);
+		expect(_internal.looksLikePiEcosystem("@scope/notpi")).toBe(false);
+	});
+});
+
+describe("PiCoreChecker.getStatus", () => {
+	let tmpManagedDir: string;
+
+	beforeEach(() => {
+		tmpManagedDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-core-test-"));
+	});
+
+	function writeManagedPackage(managedDir: string, name: string, version: string) {
+		const dir = path.join(managedDir, "node_modules", name);
+		fs.mkdirSync(dir, { recursive: true });
+		fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ name, version }));
+	}
+
+	it("discovers global pi packages via npm list", async () => {
+		const checker = new PiCoreChecker({
+			npmList: async () =>
+				JSON.stringify({
+					dependencies: {
+						"@mariozechner/pi-coding-agent": { version: "0.67.1" },
+						"pi-web-access": { version: "0.10.6" },
+						react: { version: "19.0.0" }, // must be ignored
+					},
+				}),
+			fetchLatest: async (name) => {
+				if (name === "@mariozechner/pi-coding-agent") return "0.67.6";
+				if (name === "pi-web-access") return "0.10.6";
+				return null;
+			},
+			managedDir: tmpManagedDir,
+		});
+
+		const status = await checker.getStatus();
+
+		expect(status.packages.length).toBe(2);
+		const pi = status.packages.find((p) => p.name === "@mariozechner/pi-coding-agent")!;
+		expect(pi.displayName).toBe("pi (core agent)");
+		expect(pi.currentVersion).toBe("0.67.1");
+		expect(pi.latestVersion).toBe("0.67.6");
+		expect(pi.updateAvailable).toBe(true);
+		expect(pi.installSource).toBe("global");
+
+		const web = status.packages.find((p) => p.name === "pi-web-access")!;
+		expect(web.displayName).toBe("pi-web-access");
+		expect(web.updateAvailable).toBe(false);
+		expect(web.installSource).toBe("global");
+
+		expect(status.updatesAvailable).toBe(1);
+	});
+
+	it("discovers managed packages and prefers them over global duplicates", async () => {
+		writeManagedPackage(tmpManagedDir, "@mariozechner/pi-coding-agent", "0.67.5");
+
+		const checker = new PiCoreChecker({
+			npmList: async () =>
+				JSON.stringify({
+					dependencies: {
+						"@mariozechner/pi-coding-agent": { version: "0.67.1" },
+					},
+				}),
+			fetchLatest: async () => "0.67.6",
+			managedDir: tmpManagedDir,
+		});
+
+		const status = await checker.getStatus();
+		expect(status.packages.length).toBe(1);
+		expect(status.packages[0].currentVersion).toBe("0.67.5");
+		expect(status.packages[0].installSource).toBe("managed");
+	});
+
+	it("returns empty list when managed dir missing and npm list fails", async () => {
+		const checker = new PiCoreChecker({
+			npmList: async () => {
+				throw new Error("npm not found");
+			},
+			fetchLatest: async () => null,
+			managedDir: path.join(tmpManagedDir, "nonexistent"),
+		});
+		const status = await checker.getStatus();
+		expect(status.packages).toEqual([]);
+		expect(status.updatesAvailable).toBe(0);
+	});
+
+	it("tolerates non-zero npm list exit when stdout contains valid JSON", async () => {
+		const checker = new PiCoreChecker({
+			npmList: async () => {
+				const err = new Error("npm warn") as Error & { stdout: string };
+				err.stdout = JSON.stringify({
+					dependencies: { "pi-web-access": { version: "0.10.6" } },
+				});
+				throw err;
+			},
+			fetchLatest: async () => "0.10.6",
+			managedDir: path.join(tmpManagedDir, "nope"),
+		});
+		const status = await checker.getStatus();
+		expect(status.packages.length).toBe(1);
+		expect(status.packages[0].name).toBe("pi-web-access");
+	});
+
+	it("caches results within 5 minutes", async () => {
+		let calls = 0;
+		const checker = new PiCoreChecker({
+			npmList: async () => {
+				calls++;
+				return JSON.stringify({ dependencies: { "pi-web-access": { version: "0.10.6" } } });
+			},
+			fetchLatest: async () => "0.10.6",
+			managedDir: path.join(tmpManagedDir, "nope"),
+		});
+		await checker.getStatus();
+		await checker.getStatus();
+		expect(calls).toBe(1);
+	});
+
+	it("force-refresh invalidates the cache", async () => {
+		let calls = 0;
+		const checker = new PiCoreChecker({
+			npmList: async () => {
+				calls++;
+				return JSON.stringify({ dependencies: { "pi-web-access": { version: "0.10.6" } } });
+			},
+			fetchLatest: async () => "0.10.6",
+			managedDir: path.join(tmpManagedDir, "nope"),
+		});
+		await checker.getStatus();
+		await checker.getStatus(true);
+		expect(calls).toBe(2);
+	});
+
+	it("treats fetch failure as latestVersion=null, updateAvailable=false", async () => {
+		const checker = new PiCoreChecker({
+			npmList: async () =>
+				JSON.stringify({ dependencies: { "pi-web-access": { version: "0.10.6" } } }),
+			fetchLatest: async () => {
+				throw new Error("network down");
+			},
+			managedDir: path.join(tmpManagedDir, "nope"),
+		});
+		const status = await checker.getStatus();
+		expect(status.packages.length).toBe(1);
+		expect(status.packages[0].latestVersion).toBeNull();
+		expect(status.packages[0].updateAvailable).toBe(false);
+	});
+
+	it("sorts known core packages first", async () => {
+		const checker = new PiCoreChecker({
+			npmList: async () =>
+				JSON.stringify({
+					dependencies: {
+						"pi-web-access": { version: "0.10.6" },
+						"@mariozechner/pi-coding-agent": { version: "0.67.1" },
+						"pi-agent-browser": { version: "0.1.0" },
+					},
+				}),
+			fetchLatest: async () => null,
+			managedDir: path.join(tmpManagedDir, "nope"),
+		});
+		const status = await checker.getStatus();
+		expect(status.packages[0].name).toBe("@mariozechner/pi-coding-agent");
+		// remaining are alphabetical
+		expect(status.packages[1].name).toBe("pi-agent-browser");
+		expect(status.packages[2].name).toBe("pi-web-access");
+	});
+});

package/packages/server/src/__tests__/pi-core-routes.test.ts

@@ -0,0 +1,184 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import Fastify, { type FastifyInstance } from "fastify";
+import { registerPiCoreRoutes } from "../routes/pi-core-routes.js";
+import { PackageOperationBusyError } from "../package-manager-wrapper.js";
+import type { PiCoreStatus, PiCorePackage } from "@blackbelt-technology/pi-dashboard-shared/rest-api.js";
+
+function makePkg(name: string, updateAvailable = false): PiCorePackage {
+	return {
+		name,
+		displayName: name,
+		currentVersion: "0.1.0",
+		latestVersion: updateAvailable ? "0.2.0" : "0.1.0",
+		updateAvailable,
+		installSource: "global",
+	};
+}
+
+describe("pi-core-routes", () => {
+	let app: FastifyInstance;
+	let checker: any;
+	let updater: any;
+	let onUpdateComplete: any;
+
+	beforeEach(async () => {
+		checker = {
+			getStatus: vi.fn<(refresh?: boolean) => Promise<PiCoreStatus>>(),
+			invalidate: vi.fn(),
+		};
+		updater = {
+			update: vi.fn(),
+		};
+		onUpdateComplete = vi.fn();
+		app = Fastify({ logger: false });
+		registerPiCoreRoutes(app, {
+			piCoreChecker: checker,
+			piCoreUpdater: updater,
+			onUpdateComplete,
+		});
+		await app.ready();
+	});
+
+	afterEach(async () => {
+		await app.close();
+	});
+
+	it("GET /api/pi-core/versions returns cached status", async () => {
+		const status: PiCoreStatus = {
+			packages: [makePkg("pi-web-access")],
+			updatesAvailable: 0,
+			lastChecked: new Date().toISOString(),
+		};
+		checker.getStatus.mockResolvedValue(status);
+
+		const res = await app.inject({ method: "GET", url: "/api/pi-core/versions" });
+		expect(res.statusCode).toBe(200);
+		const body = res.json() as any;
+		expect(body.success).toBe(true);
+		expect(body.data).toEqual(status);
+		expect(checker.getStatus).toHaveBeenCalledWith(false);
+	});
+
+	it("GET /api/pi-core/versions?refresh=true forces refresh", async () => {
+		checker.getStatus.mockResolvedValue({
+			packages: [],
+			updatesAvailable: 0,
+			lastChecked: new Date().toISOString(),
+		});
+		const res = await app.inject({ method: "GET", url: "/api/pi-core/versions?refresh=true" });
+		expect(res.statusCode).toBe(200);
+		expect(checker.getStatus).toHaveBeenCalledWith(true);
+	});
+
+	it("POST /api/pi-core/update with empty body updates all packages with updateAvailable", async () => {
+		checker.getStatus.mockResolvedValue({
+			packages: [makePkg("pi-web-access", true), makePkg("pi-foo", false)],
+			updatesAvailable: 1,
+			lastChecked: new Date().toISOString(),
+		});
+		updater.update.mockResolvedValue({
+			results: [{ name: "pi-web-access", success: true }],
+			sessionsReloaded: 2,
+		});
+
+		const res = await app.inject({ method: "POST", url: "/api/pi-core/update", payload: {} });
+		expect(res.statusCode).toBe(200);
+		const body = res.json() as any;
+		expect(body.success).toBe(true);
+		expect(body.data.results).toHaveLength(1);
+		expect(body.data.sessionsReloaded).toBe(2);
+
+		// Only updates the one with updateAvailable
+		expect(updater.update).toHaveBeenCalledTimes(1);
+		const arg = updater.update.mock.calls[0][0];
+		expect(arg).toHaveLength(1);
+		expect(arg[0].name).toBe("pi-web-access");
+
+		// Cache invalidated so next status reflects new versions
+		expect(checker.invalidate).toHaveBeenCalled();
+
+		// onUpdateComplete called so server can broadcast to browsers (badge refetch)
+		expect(onUpdateComplete).toHaveBeenCalledTimes(1);
+		expect(onUpdateComplete).toHaveBeenCalledWith({
+			results: [{ name: "pi-web-access", success: true }],
+			sessionsReloaded: 2,
+		});
+	});
+
+	it("POST /api/pi-core/update does not call onUpdateComplete on busy-error", async () => {
+		checker.getStatus.mockResolvedValue({
+			packages: [makePkg("pi-web-access", true)],
+			updatesAvailable: 1,
+			lastChecked: new Date().toISOString(),
+		});
+		updater.update.mockRejectedValue(new PackageOperationBusyError());
+
+		const res = await app.inject({ method: "POST", url: "/api/pi-core/update", payload: {} });
+		expect(res.statusCode).toBe(409);
+		expect(onUpdateComplete).not.toHaveBeenCalled();
+	});
+
+	it("POST /api/pi-core/update with specific packages filters to those", async () => {
+		checker.getStatus.mockResolvedValue({
+			packages: [makePkg("pi-web-access", true), makePkg("pi-foo", true)],
+			updatesAvailable: 2,
+			lastChecked: new Date().toISOString(),
+		});
+		updater.update.mockResolvedValue({ results: [{ name: "pi-foo", success: true }], sessionsReloaded: 0 });
+
+		const res = await app.inject({
+			method: "POST",
+			url: "/api/pi-core/update",
+			payload: { packages: ["pi-foo"] },
+		});
+		expect(res.statusCode).toBe(200);
+		expect(updater.update.mock.calls[0][0].map((p: PiCorePackage) => p.name)).toEqual(["pi-foo"]);
+	});
+
+	it("POST /api/pi-core/update rejects unknown packages with 400", async () => {
+		checker.getStatus.mockResolvedValue({
+			packages: [makePkg("pi-web-access", true)],
+			updatesAvailable: 1,
+			lastChecked: new Date().toISOString(),
+		});
+
+		const res = await app.inject({
+			method: "POST",
+			url: "/api/pi-core/update",
+			payload: { packages: ["not-a-real-package"] },
+		});
+		expect(res.statusCode).toBe(400);
+		const body = res.json() as any;
+		expect(body.success).toBe(false);
+		expect(body.error).toMatch(/not-a-real-package/);
+	});
+
+	it("POST /api/pi-core/update returns 409 when busy", async () => {
+		checker.getStatus.mockResolvedValue({
+			packages: [makePkg("pi-web-access", true)],
+			updatesAvailable: 1,
+			lastChecked: new Date().toISOString(),
+		});
+		updater.update.mockRejectedValue(new PackageOperationBusyError());
+
+		const res = await app.inject({ method: "POST", url: "/api/pi-core/update", payload: {} });
+		expect(res.statusCode).toBe(409);
+		const body = res.json() as any;
+		expect(body.success).toBe(false);
+	});
+
+	it("POST /api/pi-core/update returns empty result when nothing to update", async () => {
+		checker.getStatus.mockResolvedValue({
+			packages: [makePkg("pi-web-access", false)],
+			updatesAvailable: 0,
+			lastChecked: new Date().toISOString(),
+		});
+
+		const res = await app.inject({ method: "POST", url: "/api/pi-core/update", payload: {} });
+		expect(res.statusCode).toBe(200);
+		const body = res.json() as any;
+		expect(body.data.results).toEqual([]);
+		expect(body.data.sessionsReloaded).toBe(0);
+		expect(updater.update).not.toHaveBeenCalled();
+	});
+});

package/packages/server/src/__tests__/pi-core-updater.test.ts

@@ -0,0 +1,214 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { PiCoreUpdater } from "../pi-core-updater.js";
+import {
+	PackageManagerWrapper,
+	PackageOperationBusyError,
+} from "../package-manager-wrapper.js";
+import type { PiCorePackage } from "@blackbelt-technology/pi-dashboard-shared/rest-api.js";
+
+// Pi PM is mocked in other tests via vi.mock; we don't need it here because
+// we never call the install/remove/update methods — only runExclusive().
+vi.mock("@mariozechner/pi-coding-agent", () => ({
+	DefaultPackageManager: function () {
+		return {};
+	},
+	SettingsManager: { create: () => ({}) },
+}));
+
+function pkg(name: string, source: "global" | "managed" = "global"): PiCorePackage {
+	return {
+		name,
+		displayName: name,
+		currentVersion: "0.1.0",
+		latestVersion: "0.2.0",
+		updateAvailable: true,
+		installSource: source,
+	};
+}
+
+describe("PiCoreUpdater", () => {
+	let wrapper: PackageManagerWrapper;
+
+	beforeEach(() => {
+		wrapper = new PackageManagerWrapper();
+	});
+
+	it("updates packages sequentially and emits start/output/complete events", async () => {
+		const events: Array<{ name: string; phase: string; message?: string }> = [];
+		const updater = new PiCoreUpdater({
+			packageManagerWrapper: wrapper,
+			runNpmUpdate: async (p, onOutput) => {
+				onOutput("added 1 package");
+			},
+		});
+		updater.setProgressListener((e) => events.push(e));
+
+		const out = await updater.update([pkg("pi-foo"), pkg("pi-bar")]);
+
+		expect(out.results).toEqual([
+			{ name: "pi-foo", success: true },
+			{ name: "pi-bar", success: true },
+		]);
+		// Per-package: start, output, complete
+		const phases = events.map((e) => `${e.name}:${e.phase}`);
+		expect(phases).toEqual([
+			"pi-foo:start",
+			"pi-foo:output",
+			"pi-foo:complete",
+			"pi-bar:start",
+			"pi-bar:output",
+			"pi-bar:complete",
+		]);
+	});
+
+	it("continues after a failure and reports per-package errors", async () => {
+		const updater = new PiCoreUpdater({
+			packageManagerWrapper: wrapper,
+			runNpmUpdate: async (p) => {
+				if (p.name === "pi-bad") throw new Error("npm update exited with code 1");
+			},
+		});
+		const events: Array<{ phase: string }> = [];
+		updater.setProgressListener((e) => events.push({ phase: e.phase }));
+
+		const out = await updater.update([pkg("pi-bad"), pkg("pi-good")]);
+
+		expect(out.results).toEqual([
+			{ name: "pi-bad", success: false, error: "npm update exited with code 1" },
+			{ name: "pi-good", success: true },
+		]);
+		// First package emits start + error; second emits start + complete
+		expect(events.map((e) => e.phase)).toEqual(["start", "error", "start", "complete"]);
+	});
+
+	it("invokes onAllComplete only when at least one package succeeded", async () => {
+		const onAllComplete = vi.fn().mockResolvedValue(3);
+		const updater = new PiCoreUpdater({
+			packageManagerWrapper: wrapper,
+			runNpmUpdate: async () => {
+				/* success */
+			},
+			onAllComplete,
+		});
+
+		const out = await updater.update([pkg("pi-foo")]);
+		expect(out.sessionsReloaded).toBe(3);
+		expect(onAllComplete).toHaveBeenCalledTimes(1);
+	});
+
+	it("skips onAllComplete when all packages fail", async () => {
+		const onAllComplete = vi.fn().mockResolvedValue(99);
+		const updater = new PiCoreUpdater({
+			packageManagerWrapper: wrapper,
+			runNpmUpdate: async () => {
+				throw new Error("boom");
+			},
+			onAllComplete,
+		});
+
+		const out = await updater.update([pkg("pi-foo"), pkg("pi-bar")]);
+		expect(out.sessionsReloaded).toBe(0);
+		expect(onAllComplete).not.toHaveBeenCalled();
+		expect(out.results.every((r) => !r.success)).toBe(true);
+	});
+
+	it("returns 0 sessionsReloaded and does not throw when onAllComplete rejects", async () => {
+		const onAllComplete = vi.fn().mockRejectedValue(new Error("reload failed"));
+		const updater = new PiCoreUpdater({
+			packageManagerWrapper: wrapper,
+			runNpmUpdate: async () => {
+				/* success */
+			},
+			onAllComplete,
+		});
+
+		const out = await updater.update([pkg("pi-foo")]);
+		expect(out.results[0].success).toBe(true);
+		expect(out.sessionsReloaded).toBe(0);
+	});
+
+	it("acquires the shared busy-lock and throws when wrapper is already busy", async () => {
+		// Start a long-running runExclusive on the wrapper to simulate an
+		// extension operation in flight.
+		let release!: () => void;
+		const held = new Promise<void>((r) => {
+			release = r;
+		});
+		const locked = wrapper.runExclusive(() => held);
+
+		const updater = new PiCoreUpdater({
+			packageManagerWrapper: wrapper,
+			runNpmUpdate: async () => {
+				/* no-op */
+			},
+		});
+
+		await expect(updater.update([pkg("pi-foo")])).rejects.toBeInstanceOf(
+			PackageOperationBusyError,
+		);
+
+		// Release the held lock and confirm a subsequent update succeeds.
+		release();
+		await locked;
+
+		const out = await updater.update([pkg("pi-foo")]);
+		expect(out.results[0].success).toBe(true);
+	});
+
+	it("releases the busy-lock after update completes (success path)", async () => {
+		const updater = new PiCoreUpdater({
+			packageManagerWrapper: wrapper,
+			runNpmUpdate: async () => {
+				/* success */
+			},
+		});
+		await updater.update([pkg("pi-foo")]);
+		expect(wrapper.isBusy()).toBe(false);
+		// Second call should be immediately permitted.
+		const out = await updater.update([pkg("pi-bar")]);
+		expect(out.results[0].success).toBe(true);
+	});
+
+	it("releases the busy-lock even when every package fails", async () => {
+		const updater = new PiCoreUpdater({
+			packageManagerWrapper: wrapper,
+			runNpmUpdate: async () => {
+				throw new Error("nope");
+			},
+		});
+		await updater.update([pkg("pi-foo")]);
+		expect(wrapper.isBusy()).toBe(false);
+	});
+
+	it("passes install-source-aware args & cwd to runNpmUpdate", async () => {
+		const seen: Array<{ name: string; source: "global" | "managed" }> = [];
+		const updater = new PiCoreUpdater({
+			packageManagerWrapper: wrapper,
+			runNpmUpdate: async (p) => {
+				seen.push({ name: p.name, source: p.installSource });
+			},
+		});
+		await updater.update([pkg("pi-foo", "global"), pkg("pi-bar", "managed")]);
+		expect(seen).toEqual([
+			{ name: "pi-foo", source: "global" },
+			{ name: "pi-bar", source: "managed" },
+		]);
+	});
+
+	it("swallows progress-listener exceptions without failing the update", async () => {
+		const updater = new PiCoreUpdater({
+			packageManagerWrapper: wrapper,
+			runNpmUpdate: async () => {
+				/* success */
+			},
+		});
+		updater.setProgressListener(() => {
+			throw new Error("listener explosion");
+		});
+		// Silence the console.error emitted by the safe-emit guard
+		const err = vi.spyOn(console, "error").mockImplementation(() => {});
+		const out = await updater.update([pkg("pi-foo")]);
+		expect(out.results[0].success).toBe(true);
+		err.mockRestore();
+	});
+});