@danypops/pi-packed 0.27.14 → 0.28.1

package/dist/adoption/smoke.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"smoke.d.ts","sourceRoot":"","sources":["../../service/src/adoption/smoke.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,mBAAmB,GAAG,cAAc,GAAG,qBAAqB,CAAC;AAEpH,MAAM,WAAW,kBAAkB;IAClC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,kBAAkB,CAAC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AA2BD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAO7F;AA4ID,wBAAsB,iBAAiB,CACtC,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE,YAAiB,GACxB,OAAO,CAAC,oBAAoB,CAAC,CAoF/B"}
+{"version":3,"file":"smoke.d.ts","sourceRoot":"","sources":["../../service/src/adoption/smoke.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,mBAAmB,GAAG,cAAc,GAAG,qBAAqB,CAAC;AAEpH,MAAM,WAAW,kBAAkB;IAClC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,kBAAkB,CAAC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAuDD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAO7F;AAmJD,wBAAsB,iBAAiB,CACtC,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE,YAAiB,GACxB,OAAO,CAAC,oBAAoB,CAAC,CAoF/B"}

package/extension/src/bounded-poll.ts

@@ -0,0 +1,19 @@
+/**
+ * Idempotent start/stop wrapper over setInterval -- a second start() is a no-op rather than a
+ * competing timer, and stop() is safe to call even if never started. Same shape as pi-papyrus's
+ * and pi-pipes' own BoundedPoll.
+ */
+export class BoundedPoll {
+	private timer: ReturnType<typeof setInterval> | undefined;
+
+	start(intervalMs: number, tick: () => void): void {
+		if (this.timer) return;
+		this.timer = setInterval(tick, intervalMs);
+	}
+
+	stop(): void {
+		if (!this.timer) return;
+		clearInterval(this.timer);
+		this.timer = undefined;
+	}
+}

package/extension/src/doctor-overlay.ts

@@ -0,0 +1,156 @@
+/**
+ * Persistent above-editor widget for real doctor.run issues -- mirrors pi-papyrus's own
+ * TaskOverlay/NoteOverlay and pi-pipes' own JobsOverlay: factory-form ctx.ui.setWidget
+ * registration, requestRender on refresh, hides the widget entirely (setWidget(key, undefined))
+ * rather than an empty box once the report is clean.
+ *
+ * doctor.run lives exclusively on the daemon's Vehicle protocol surface (/vehicle/*), not the
+ * legacy PackedExtensionClient RPC surface packed.ts's Natives wraps (see ExtensionOperationName
+ * in protocol.ts -- "doctor.run" is not one of them) -- this overlay builds its own reconnecting
+ * VehicleClient the same way vehicle-tools.ts's registerPackedVehicle does.
+ *
+ * Polled at a conservative interval (see DOCTOR_WIDGET_POLL_INTERVAL_MS): unlike Tasks/Notes/Jobs,
+ * doctor.run is a real daemon-wide scan (extension smoke tests, npm-tree walks, systemd
+ * shell-outs), not a cheap row read.
+ */
+import type { DoctorReport } from "@danypops/pi-packed/doctor-format";
+import { createReconnectingVehicleClient } from "@danypops/vehicle-client/daemon-client";
+import { RemoteVehicleClient } from "@danypops/vehicle-client/http";
+import type { VehicleClient } from "@danypops/vehicle-core";
+import type { ExtensionUIContext, Theme } from "@earendil-works/pi-coding-agent";
+import { AutoRotatingWindow } from "malevich-tui-components";
+import { BoundedPoll } from "./bounded-poll.js";
+import {
+	buildDoctorWidgetProjection,
+	type DoctorWidgetProjection,
+	PACKED_DOCTOR_WIDGET_VISIBLE_ROWS,
+	renderDoctorWidgetLines,
+} from "./doctor-widget.js";
+import { currentVehicleClientTarget } from "./vehicle-target.js";
+
+const WIDGET_KEY = "pi-packed-doctor";
+
+/** doctor.run is a real daemon-wide scan, not a cheap row read -- a much longer interval than
+ * Tasks/Notes/Jobs' own 15-20s cadence. */
+export const DOCTOR_WIDGET_POLL_INTERVAL_MS = 90_000;
+
+/** How often the widget's own auto-rotating overflow page advances. */
+export const DOCTOR_WIDGET_ROTATION_INTERVAL_MS = 6_000;
+
+const EMPTY_PROJECTION: DoctorWidgetProjection = { issues: [], total: 0 };
+
+function defaultClient(): VehicleClient {
+	// connectRetry:true (vehicle-client's own bounded background retry budget) covers a daemon
+	// that crashed and is mid systemd-restart -- matches registerPackedVehicle's own construction.
+	return createReconnectingVehicleClient(
+		async () => {
+			const resolved = currentVehicleClientTarget();
+			if (!resolved) throw new Error("Packed daemon is not running");
+			return new RemoteVehicleClient({ baseUrl: resolved.baseUrl, token: resolved.token });
+		},
+		{ connectRetry: true },
+	);
+}
+
+export class DoctorOverlay {
+	private uiCtx: ExtensionUIContext | undefined;
+	private registered = false;
+	// biome-ignore lint/suspicious/noExplicitAny: same TUI-handle shape every other overlay in this ecosystem keeps untyped (requestRender is all that's used).
+	private tui: any | undefined;
+	private projection: DoctorWidgetProjection = EMPTY_PROJECTION;
+	private readonly poll = new BoundedPoll();
+	/** Repaint-only ticker (no data refetch) so the widget's own auto-rotating page visibly
+	 * advances even when nothing else has changed. */
+	private readonly rotationPoll = new BoundedPoll();
+	private readonly rotation = new AutoRotatingWindow({
+		totalRows: 0,
+		pageSize: PACKED_DOCTOR_WIDGET_VISIBLE_ROWS,
+		intervalMs: DOCTOR_WIDGET_ROTATION_INTERVAL_MS,
+	});
+	private readonly client: VehicleClient;
+
+	constructor(client: VehicleClient = defaultClient()) {
+		this.client = client;
+	}
+
+	setUI(ctx: ExtensionUIContext): void {
+		if (ctx !== this.uiCtx) {
+			this.uiCtx = ctx;
+			this.registered = false;
+			this.tui = undefined;
+		}
+	}
+
+	/** Never throws: called from a poll timer and from session_start, neither of which should turn
+	 * a best-effort status widget into a crashed extension host over a daemon that isn't running
+	 * yet or a rendering bug. */
+	async refresh(): Promise<void> {
+		try {
+			const report = await this.client.invoke<DoctorReport>("doctor.run", 1, {}, { permissions: ["packed:read"] });
+			this.projection = buildDoctorWidgetProjection(report);
+		} catch {
+			this.projection = EMPTY_PROJECTION;
+		}
+		try {
+			this.render();
+		} catch {
+			// A rendering bug must not crash the extension host over a best-effort status widget.
+		}
+	}
+
+	private render(): void {
+		if (!this.uiCtx) return;
+
+		if (this.projection.total === 0) {
+			if (this.registered) {
+				this.uiCtx.setWidget(WIDGET_KEY, undefined);
+				this.registered = false;
+				this.tui = undefined;
+				this.rotationPoll.stop();
+			}
+			return;
+		}
+
+		if (!this.registered) {
+			this.uiCtx.setWidget(
+				WIDGET_KEY,
+				// biome-ignore lint/suspicious/noExplicitAny: tui is only ever used for requestRender(), matching every other overlay in this ecosystem.
+				(tui: any, theme: Theme) => {
+					this.tui = tui;
+					return {
+						render: (width: number) => renderDoctorWidgetLines(theme, this.projection, width, this.rotation),
+						invalidate: () => {
+							// Theme changed -- force re-registration, matching every other overlay in this ecosystem.
+							this.registered = false;
+							this.tui = undefined;
+						},
+					};
+				},
+				{ placement: "aboveEditor" },
+			);
+			this.registered = true;
+			this.rotationPoll.start(DOCTOR_WIDGET_ROTATION_INTERVAL_MS, () => this.tui?.requestRender?.());
+		} else {
+			this.tui?.requestRender?.();
+		}
+	}
+
+	startPolling(intervalMs: number = DOCTOR_WIDGET_POLL_INTERVAL_MS): void {
+		this.poll.start(intervalMs, () => {
+			void this.refresh();
+		});
+	}
+
+	stopPolling(): void {
+		this.poll.stop();
+	}
+
+	dispose(): void {
+		this.stopPolling();
+		this.rotationPoll.stop();
+		this.uiCtx?.setWidget(WIDGET_KEY, undefined);
+		this.registered = false;
+		this.tui = undefined;
+		this.uiCtx = undefined;
+	}
+}

package/extension/src/doctor-widget.ts

@@ -0,0 +1,86 @@
+/**
+ * Pure projection/render pair for the Doctor status widget -- mirrors pi-papyrus's own
+ * task-widget.ts / pi-pipes' own jobs-widget.ts split: a DoctorReport in, a bounded intermediate
+ * shape out, no I/O, no TUI, fully unit-testable without a real daemon or terminal. See
+ * doctor-overlay.ts for the stateful ctx.ui.setWidget-registered class that drives these from a
+ * live doctor.run poll.
+ */
+import type { DoctorReport } from "@danypops/pi-packed/doctor-format";
+import { vehicleWidgetTitle } from "@danypops/vehicle-client-pi/widget-header";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { type AutoRotatingWindow, renderCardRow, type TextMeasure } from "malevich-tui-components";
+
+const measure: TextMeasure = { visibleWidth, truncateToWidth, wrapTextWithAnsi };
+
+/** The daemon's own manifest name (see service/src/daemon/service.ts's `new VehicleRegistry({ name: "packed" })`) -- vehicleWidgetTitle capitalizes it for display. */
+const VEHICLE_NAME = "packed";
+
+/** Visible issue rows per page before the auto-rotating overflow hint pages to the next. */
+export const PACKED_DOCTOR_WIDGET_VISIBLE_ROWS = 5;
+
+export interface DoctorWidgetIssue {
+	label: string;
+}
+
+export interface DoctorWidgetProjection {
+	issues: DoctorWidgetIssue[];
+	total: number;
+}
+
+/**
+ * Mirrors doctor.run's own `ok` computation (conflicts + non-ok extensions + serviceUnits), plus
+ * stale module-cache entries (directly actionable: "restart the daemon"). Deliberately excludes
+ * duplicateDependencies -- doctor.run's own `ok` boolean excludes them too (see doctor-format.ts's
+ * own doc comment on why), and they're common enough in this ecosystem's own staggered version
+ * rollout to be low-signal for a persistent glance-at-a-widget summary.
+ */
+export function buildDoctorWidgetProjection(report: DoctorReport): DoctorWidgetProjection {
+	const issues: DoctorWidgetIssue[] = [];
+	for (const conflict of report.conflicts) {
+		issues.push({ label: `${conflict.kind} "${conflict.name}" claimed by ${conflict.claimants.length} extensions` });
+	}
+	for (const extension of report.extensions) {
+		if (extension.status === "ok") continue;
+		issues.push({ label: `${extension.status} ${extension.name}${extension.message ? `: ${extension.message}` : ""}` });
+	}
+	for (const unit of report.serviceUnits) {
+		issues.push({ label: `${unit.package} (${unit.unitName}): ${unit.message}` });
+	}
+	for (const module of report.moduleFreshness ?? []) {
+		if (!module.stale) continue;
+		issues.push({ label: `${module.name} loaded ${module.loadedVersion ?? "?"}, disk has ${module.currentVersion ?? "?"}` });
+	}
+	return { issues, total: issues.length };
+}
+
+/** "Packed · Doctor · <N> issue(s)", plus a "page/total ⟳" suffix once genuinely paging. */
+function doctorCardLabel(projection: DoctorWidgetProjection, rotation?: AutoRotatingWindow): string {
+	const base = vehicleWidgetTitle(VEHICLE_NAME, "Doctor", `${projection.total} issue${projection.total === 1 ? "" : "s"}`);
+	return rotation?.isPaging ? `${base} · ${rotation.pageIndex + 1}/${rotation.pageCount} ⟳` : base;
+}
+
+/** Renders the widget as a single bordered card -- `[]` (hide the whole widget) when there are no
+ * real issues, matching every other overlay's own "hide when nothing to show" convention. */
+export function renderDoctorWidgetLines(
+	theme: { fg(color: string, text: string): string },
+	projection: DoctorWidgetProjection,
+	width: number,
+	rotation?: AutoRotatingWindow,
+): string[] {
+	if (projection.total === 0) return [];
+	rotation?.setTotalRows(projection.issues.length);
+	const { start, end } = rotation?.currentPageBounds() ?? { start: 0, end: projection.issues.length };
+	const visibleIssues = projection.issues.slice(start, end);
+
+	return renderCardRow(
+		[
+			{
+				label: doctorCardLabel(projection, rotation),
+				render: (innerWidth: number) =>
+					visibleIssues.map((issue) => truncateToWidth(`${theme.fg("warning", "!")} ${issue.label}`, innerWidth, "…")),
+			},
+		],
+		width,
+		{ measure, frameStyle: (s) => theme.fg("borderMuted", s) },
+	);
+}

package/extension/src/index.ts

@@ -9,6 +9,7 @@
  * Install: pi install git:github.com/DanyPops/pi-packed
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { DoctorOverlay } from "./doctor-overlay.js";
 import { formatUpdateNotice } from "./model.js";
 import { createNatives } from "./packed.js";
 import { registerProfiles } from "./profile.js";
@@ -42,6 +43,7 @@ export default async function (pi: ExtensionAPI) {
 	// the identical pi-papyrus/pi-tickets bug). session_start fires only after that initialization
 	// completes, and Pi awaits every session_start handler before the model's first turn, so
 	// registering here is both safe and still visible on turn one.
+	let doctorOverlay: DoctorOverlay | undefined;
 	pi.on("session_start", async (_event, ctx) => {
 		await registerPackedVehicle(pi);
 		if (!ctx.hasUI) return;
@@ -53,5 +55,12 @@ export default async function (pi: ExtensionAPI) {
 		} catch {
 			// mirror missing or unreadable — stay silent, never block startup.
 		}
+		doctorOverlay ??= new DoctorOverlay();
+		doctorOverlay.setUI(ctx.ui);
+		await doctorOverlay.refresh();
+		doctorOverlay.startPolling();
+	});
+	pi.on("session_shutdown", async () => {
+		doctorOverlay?.dispose();
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-packed",
-  "version": "0.27.14",
+  "version": "0.28.1",
   "description": "Pi package lifecycle, validation, daemon, tools, profiles, and TUI",
   "type": "module",
   "bin": {
@@ -34,7 +34,7 @@
     "@danypops/vehicle-core": "^0.17.1",
     "@danypops/vehicle-server": "^0.25.2",
     "jiti": "^2.7.0",
-    "malevich-tui-components": "^0.21.1",
+    "malevich-tui-components": "^0.32.1",
     "publint": "0.3.22",
     "semver": "^7.8.5"
   },

package/service/src/adoption/smoke.ts

@@ -54,6 +54,34 @@ function addReadOnlyBind(args: string[], path: string): void {
 	if (existsSync(path)) args.push("--ro-bind", path, path);
 }
 
+const MAX_ANCESTOR_WALK = 32;
+
+/**
+ * Every ancestor directory's own node_modules from packageRoot's parent up to
+ * the filesystem root -- mirrors Node's real module-resolution walk
+ * (require.resolve checks <dir>/node_modules at every level up to /).
+ * Confirmed live: packed doctor's own widget reported real extensions
+ * (pi-lector, pi-pipes, pi-tickets, pi-jittor, pi-web-spider) as "crash" on a
+ * plain Cannot-find-module for a sibling dependency npm/bun hoisted to a
+ * shared ancestor node_modules, though Pi's own real, unsandboxed process
+ * resolves the exact same import fine -- the sandbox only ever bound the
+ * package's own root, never the hoisted siblings one or more levels above it.
+ * Bounded to MAX_ANCESTOR_WALK levels as a defensive cap; a real filesystem
+ * hierarchy never gets remotely close to that before reaching /.
+ */
+function collectAncestorNodeModulesDirs(packageRoot: string): string[] {
+	const dirs: string[] = [];
+	let current = dirname(packageRoot);
+	for (let i = 0; i < MAX_ANCESTOR_WALK; i++) {
+		const candidate = join(current, "node_modules");
+		if (existsSync(candidate)) dirs.push(realpathSync(candidate));
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return dirs;
+}
+
 /**
  * Resolves an installed dependency's real on-disk package directory via
  * Node's own module-resolution algorithm (require.resolve against its
@@ -85,7 +113,6 @@ function sandboxCommand(packageRoot: string, extensionPath: string, maxProcesses
 	const jitiModules = resolveDependencyModulesDir(packageDirectory, "jiti");
 	if (!jitiModules) return undefined;
 	const bun = realpathSync(process.execPath);
-	const relativeExtension = relative(packageRoot, extensionPath).split(sep).join("/");
 	const args = [
 		"/usr/bin/bwrap",
 		"--unshare-user",
@@ -116,9 +143,6 @@ function sandboxCommand(packageRoot: string, extensionPath: string, maxProcesses
 		jitiModules,
 		"/runner/node_modules/jiti",
 		"--ro-bind",
-		packageRoot,
-		"/package",
-		"--ro-bind",
 		bun,
 		"/bun",
 		"--dev",
@@ -131,6 +155,17 @@ function sandboxCommand(packageRoot: string, extensionPath: string, maxProcesses
 		"/tmp",
 		"--dir",
 		"/tmp/home",
+	);
+	// Package-related identity binds go AFTER the virtual/tmpfs mounts above --
+	// bwrap applies mounts in argument order, so a bind whose real path happens
+	// to sit under one of those special mounts (e.g. a test fixture under
+	// /tmp, which --tmpfs /tmp would otherwise shadow) must come later to win.
+	addReadOnlyBind(args, packageRoot);
+	// Real-path identity binds so a hoisted sibling dependency resolves exactly
+	// as it would in Pi's own real, unsandboxed process -- see
+	// collectAncestorNodeModulesDirs's own doc comment for why this is needed.
+	for (const dir of collectAncestorNodeModulesDirs(packageRoot)) addReadOnlyBind(args, dir);
+	args.push(
 		"--remount-ro",
 		"/",
 		"--clearenv",
@@ -147,7 +182,7 @@ function sandboxCommand(packageRoot: string, extensionPath: string, maxProcesses
 		"NODE_PATH",
 		"/runner/node_modules",
 		"--chdir",
-		"/package",
+		packageRoot,
 		"--",
 		"/usr/bin/prlimit",
 		`--nproc=${maxProcesses}`,
@@ -158,7 +193,7 @@ function sandboxCommand(packageRoot: string, extensionPath: string, maxProcesses
 		"--",
 		"/bun",
 		"/runner/src/smoke-child.ts",
-		`/package/${relativeExtension}`,
+		extensionPath,
 	);
 	return args;
 }

package/service/test/smoke.test.ts

@@ -151,6 +151,35 @@ describeIfSandboxed("isolated extension smoke runner", () => {
 		expect((await runExtensionSmoke(output.root, output.path, { maxOutputBytes: 4_096 })).status).toBe("output-limit");
 	});
 
+	it("resolves a dependency hoisted to a shared ancestor node_modules -- confirmed live bug: packed doctor's own widget reported 5/8 real extensions as crashing on a plain 'Cannot find module' for a sibling dependency npm/bun hoisted above the package's own node_modules, though Pi's own real, unsandboxed process resolves the exact same import fine", async () => {
+		const workspaceRoot = mkdtempSync(join(tmpdir(), "packed-smoke-hoisted-"));
+		roots.push(workspaceRoot);
+		const sharedNodeModules = join(workspaceRoot, "node_modules");
+		writeFakeDependency(sharedNodeModules, "hoisted-sibling");
+		const packageDir = join(sharedNodeModules, "@fixture", "pi-smoke-hoisted");
+		mkdirSync(join(packageDir, "extension"), { recursive: true });
+		const extensionPath = join(packageDir, "extension", "index.ts");
+		writeFileSync(
+			extensionPath,
+			'import pkg from "hoisted-sibling/package.json" with { type: "json" };\nexport default function (pi: any) { pi.registerCommand(pkg.name, { handler() {} }); }\n',
+		);
+		writeFileSync(
+			join(packageDir, "package.json"),
+			JSON.stringify({
+				name: "@fixture/pi-smoke-hoisted",
+				version: "1.0.0",
+				keywords: ["pi-package"],
+				files: ["extension"],
+				pi: { extensions: ["extension/index.ts"] },
+			}),
+		);
+
+		const result = await runExtensionSmoke(packageDir, extensionPath);
+
+		expect(result.status).toBe("ok");
+		expect(result.registrations.commands).toEqual(["hoisted-sibling"]);
+	});
+
 	it("keeps default package checks static and adds smoke results only when requested", async () => {
 		const fixture = extension(
 			'import { writeFileSync } from "node:fs"; export default function (pi: any) { writeFileSync("executed", "yes"); pi.registerCommand("x", { handler() {} }); }',