@danypops/pi-packed 0.21.13 → 0.21.14

package/service/src/packages/install.ts

@@ -1,10 +1,21 @@
 /** install.ts — driven adapter: pi CLI mutations via Bun.spawn. */
 
 import { join } from "node:path";
-import { HeadlessInstallValidator, type InstallValidator } from "../adoption/install-validation.ts";
+import type { Logger } from "@danypops/vehicle-server/logging";
+import {
+	assertInstallValidationOk,
+	HeadlessInstallValidator,
+	type InstallValidationResult,
+	type InstallValidator,
+} from "../adoption/install-validation.ts";
+import { createLogger } from "../shared/log.ts";
 import { defaultPiHome, isPinnedNpmSource, readResolvedVersion } from "./installed.ts";
 import type { Installer, UpdateOutcome } from "./package.ts";
 
+function round1(ms: number): number {
+	return Math.round(ms * 10) / 10;
+}
+
 /** Bare npm package name (for `packed remove`). */
 export const NAME_RE = /^(@[A-Za-z0-9._-]+\/)?[A-Za-z0-9._-]+$/;
 
@@ -22,10 +33,27 @@ export class ExecInstaller implements Installer {
 		private piHome = defaultPiHome(),
 		private validator: InstallValidator = new HeadlessInstallValidator(),
 		private npmBin = defaultNpmBin(),
+		/**
+		 * Instrumentation only -- never gates behavior. Each install()/update() call logs one
+		 * "install timing"/"update timing" debug line breaking down where its wall-clock time went
+		 * (validateMs/installMs/reresolveMs, plus totalMs): the real, previously-invisible cost of
+		 * installing/updating several packages one at a time (see SetupManager.apply()'s own
+		 * sequential loop) is dominated by reresolveDependencyTree() -- a FULL `npm install` at
+		 * piHome/npm re-run after every single package, not just the newly touched one. Surfacing
+		 * that split here is what let service/test/perf/multi-install.perf.test.ts quantify it
+		 * against a real daemon instead of guessing from wall-clock totals alone.
+		 */
+		private readonly logger: Logger = createLogger("install"),
 	) {}
 
 	private async run(args: string[]): Promise<string> {
-		const proc = Bun.spawn([this.bin, ...args], { stdout: "pipe", stderr: "pipe" });
+		// env is explicit, not Bun.spawn's own default-inherited env: a caller that redirects Pi's
+		// home via a runtime process.env mutation (e.g. PI_CODING_AGENT_DIR, set after this process
+		// already started -- confirmed live from service/test/perf/multi-install.perf.test.ts) needs
+		// that reflected in the CURRENT process.env object, not whatever snapshot Bun's own default
+		// inheritance captured. Silently missing this sent a real run straight into the developer's
+		// actual ~/.pi/agent instead of the intended isolated temp directory.
+		const proc = Bun.spawn([this.bin, ...args], { stdout: "pipe", stderr: "pipe", env: process.env });
 		const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
 		const out = [stdout.trim(), stderr.trim()].filter(Boolean).join("\n");
 		const code = await proc.exited;
@@ -42,28 +70,70 @@ export class ExecInstaller implements Installer {
 	 * resolution silently walks up to a stale copy nothing wanted. A full
 	 * `npm install` (no args) at piHome/npm is npm's own documented reliable
 	 * fix: it re-resolves the whole tree, not just the last-touched package.
+	 *
+	 * Public (not private) so a batch caller -- see SetupManager.apply() -- can call this ONCE
+	 * after committing every package in a batch via installOnly(), instead of install()/update()
+	 * each calling it once per package. Safe to call as often as today regardless: re-resolving an
+	 * already-consistent tree is a cheap no-op for npm, never itself a source of drift.
 	 */
-	private async reresolveDependencyTree(): Promise<string> {
+	async reresolveDependencyTree(): Promise<string> {
+		const t0 = performance.now();
 		const cwd = join(this.piHome, "npm");
-		const proc = Bun.spawn([this.npmBin, "install"], { cwd, stdout: "pipe", stderr: "pipe" });
+		// See run()'s own comment: env is explicit for the identical reason.
+		const proc = Bun.spawn([this.npmBin, "install"], { cwd, stdout: "pipe", stderr: "pipe", env: process.env });
 		const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
 		const out = [stdout.trim(), stderr.trim()].filter(Boolean).join("\n");
 		const code = await proc.exited;
 		if (code !== 0) throw new Error(`npm install failed to re-resolve the dependency tree at ${cwd} (exit ${code}): ${out || "no output"}`);
+		this.logger.debug("reresolve timing", { reresolveMs: round1(performance.now() - t0) });
 		return out;
 	}
 
-	async install(source: string, options?: { approved?: boolean; local?: boolean }): Promise<string> {
-		const validation = await this.validator.validate(source);
-		if (!validation.ok) {
-			const detail = validation.extensions
-				.filter((extension) => !extension.ok)
-				.map((extension) => `${extension.path}: ${extension.message}`)
-				.join("; ");
-			throw new Error(`install refused -- ${detail || validation.message || "extension failed a headless load check"}`);
-		}
+	/**
+	 * Safe to run CONCURRENTLY across many sources -- see Installer.validate's own doc comment.
+	 * Delegates to whatever InstallValidator this instance was constructed with (real:
+	 * HeadlessInstallValidator, stages into its own throwaway temp dir per call).
+	 */
+	async validate(source: string): Promise<InstallValidationResult> {
+		const t0 = performance.now();
+		const result = await this.validator.validate(source);
+		this.logger.debug("validate timing", { source, validateMs: round1(performance.now() - t0) });
+		return result;
+	}
+
+	/**
+	 * The real `pi install` mutation alone -- no validation (call validate() first; install()
+	 * does both, in order, for a single ad hoc caller), no trailing reresolveDependencyTree() (a
+	 * batch caller defers that to once per batch, not once per package). MUST be awaited
+	 * sequentially across a batch, never run concurrently -- see Installer.installOnly's own doc
+	 * comment for the confirmed settings.json/package.json corruption a naive Promise.all here
+	 * produces.
+	 */
+	async installOnly(source: string, options?: { approved?: boolean; local?: boolean }): Promise<string> {
+		const t0 = performance.now();
 		const output = await this.run(["install", ...(options?.local ? ["-l"] : []), source]);
+		this.logger.debug("installOnly timing", { source, installMs: round1(performance.now() - t0) });
+		return output;
+	}
+
+	async install(source: string, options?: { approved?: boolean; local?: boolean }): Promise<string> {
+		const t0 = performance.now();
+		const validation = await this.validate(source);
+		const validateMs = performance.now() - t0;
+		assertInstallValidationOk(validation);
+		const t1 = performance.now();
+		const output = await this.installOnly(source, options);
+		const installMs = performance.now() - t1;
+		const t2 = performance.now();
 		await this.reresolveDependencyTree();
+		const reresolveMs = performance.now() - t2;
+		this.logger.debug("install timing", {
+			source,
+			validateMs: round1(validateMs),
+			installMs: round1(installMs),
+			reresolveMs: round1(reresolveMs),
+			totalMs: round1(performance.now() - t0),
+		});
 		return output;
 	}
 
@@ -72,10 +142,21 @@ export class ExecInstaller implements Installer {
 	}
 
 	async update(source: string, _options?: { approved?: boolean; local?: boolean }): Promise<UpdateOutcome> {
+		const t0 = performance.now();
 		const pinned = isPinnedNpmSource(source);
 		const previousVersion = readResolvedVersion(this.piHome, source);
+		const t1 = performance.now();
 		const output = await this.run(["update", "--extension", source]);
+		const updateMs = performance.now() - t1;
+		const t2 = performance.now();
 		await this.reresolveDependencyTree();
+		const reresolveMs = performance.now() - t2;
+		this.logger.debug("update timing", {
+			source,
+			updateMs: round1(updateMs),
+			reresolveMs: round1(reresolveMs),
+			totalMs: round1(performance.now() - t0),
+		});
 		const currentVersion = readResolvedVersion(this.piHome, source);
 		// Only trust a "nothing changed" conclusion when we actually read a
 		// real version both before and after (npm source, resolvable in

package/service/src/packages/package.ts

@@ -5,6 +5,13 @@
  * shells out to pi).
  */
 
+// InstallValidationResult is a plain, adapter-neutral DTO (ok/source/extensions/message) --
+// imported type-only (erased at compile time) from the one adapter that currently produces it
+// (HeadlessInstallValidator) rather than duplicating its shape here and risking drift. Installer
+// itself stays a pure port: nothing here creates a runtime dependency on install-validation.ts's
+// own npm-pack/tar/subprocess machinery.
+import type { InstallValidationResult } from "../adoption/install-validation.ts";
+
 export type PackageVerification = "keyword-only" | "manifest" | "conventional";
 
 export interface PackageEvidence {
@@ -30,6 +37,10 @@ export interface Pkg {
 	version: string;
 	description?: string;
 	date?: string;
+	/** From npm's own search API response (each hit already carries this inline -- no extra
+	 * request per result, unlike PkgInfo.downloads, which needs its own dedicated fetch for a
+	 * single already-known package). See HttpRegistry.searchPage(). */
+	downloads?: DownloadObservations;
 	packageEvidence?: PackageEvidence;
 	publication?: PublicationEvidence;
 }
@@ -104,6 +115,30 @@ export interface Installer {
 	install(source: string, options?: { approved?: boolean; local?: boolean }): Promise<string>;
 	remove(source: string, options?: { approved?: boolean; local?: boolean }): Promise<string>;
 	update(source: string, options?: { approved?: boolean; local?: boolean }): Promise<UpdateOutcome>;
+	/**
+	 * Optional batch-oriented split of install(), for a caller installing several packages
+	 * together (see SetupManager.apply()) -- a single ad hoc install() still does all three
+	 * steps itself and needs none of this; every existing Installer implementation that omits
+	 * these three keeps compiling and behaving exactly as before.
+	 *
+	 * validate() is safe to run CONCURRENTLY across many sources: each call stages into its own
+	 * throwaway temp directory (see HeadlessInstallValidator) with zero shared state between
+	 * packages. installOnly() does the real `pi install` mutation WITHOUT install()'s own
+	 * trailing full-tree reresolve, so a batch caller can defer that to
+	 * reresolveDependencyTree(), called ONCE after every package in the batch instead of once
+	 * per package.
+	 *
+	 * installOnly() itself must stay SEQUENTIAL across a batch, never fanned out the way
+	 * validate() can be: `pi install` does its own non-atomic read-modify-write of both
+	 * settings.json and the npm project's package.json/package-lock.json in the single shared
+	 * piHome, with no locking on either side (confirmed empirically -- three concurrent `pi
+	 * install` calls against one piHome silently lost two of three entries from settings.json
+	 * and npm/package.json, while all three packages' node_modules ended up physically present
+	 * but untracked, exactly the state a later reresolveDependencyTree() would then prune).
+	 */
+	validate?(source: string): Promise<InstallValidationResult>;
+	installOnly?(source: string, options?: { approved?: boolean; local?: boolean }): Promise<string>;
+	reresolveDependencyTree?(): Promise<string>;
 }
 
 export interface InstalledPkg {

package/service/src/public/client.ts

@@ -89,6 +89,35 @@ export function resolvePackedClientPaths(options: PackedPathOptions = {}): Packe
 	return { token: paths.token, handle: paths.handle, serviceDescriptor: paths.serviceDescriptor };
 }
 
+export interface PackedVehicleClientTarget {
+	/** Base URL for the daemon's Vehicle-projected surface (see service.ts's createApp, which mounts
+	 * createVehicleHttpApp() at /vehicle/* on this same port, alongside /api/v1/ops) -- @danypops/
+	 * vehicle-client's RemoteVehicleClient mounts its own /vehicle/manifest, /vehicle/invoke,
+	 * /vehicle/cancel routes under this. */
+	baseUrl: string;
+	token: string;
+}
+
+/**
+ * Narrow surface for a Vehicle-projected operation consumer -- same daemon, same handle file, same
+ * Bearer token every other Packed RPC call already uses (connectPackedClient reads both the same
+ * way). Returns undefined rather than throwing when the daemon has never started -- no handle/token
+ * on disk yet -- matching resolvePushChannelTarget/resolveVehicleClientTarget's own tolerance in
+ * @danypops/papyrus for the identical condition.
+ */
+export function resolveVehicleClientTarget(paths = resolvePackedClientPaths()): PackedVehicleClientTarget | undefined {
+	const handle = readDaemonHandle(paths.handle);
+	if (!handle) return undefined;
+	let token: string;
+	try {
+		token = readFileSync(paths.token, "utf8").trim();
+	} catch {
+		return undefined;
+	}
+	if (!/^[a-f0-9]{64}$/.test(token)) return undefined;
+	return { baseUrl: `http://${handle.host}:${handle.port}`, token };
+}
+
 /** Checks Armada's authoritative desired fleet rather than native descriptor files. */
 function isPackedServiceInstalled(): boolean {
 	return vehicleIsServiceInstalled(SERVICE_NAME, createNodeServiceInstallDeps());

package/service/src/public/protocol.ts

@@ -8,11 +8,17 @@ export interface PublicationEvidence {
 	provenanceUrl?: string;
 	trustedPublisher: "verified" | "not-verified" | "unknown";
 }
+export interface DownloadObservations {
+	weekly?: number;
+	monthly?: number;
+	observedAt: string;
+}
 export interface PackageSummary {
 	name: string;
 	version: string;
 	description?: string;
 	date?: string;
+	downloads?: DownloadObservations;
 	packageEvidence?: PackageEvidence;
 	publication?: PublicationEvidence;
 }

package/service/src/registry/registry.ts

@@ -71,10 +71,20 @@ export class HttpRegistry implements Registry {
 		if (!res.ok) throw new Error(`npm search: HTTP ${res.status}`);
 		const doc = (await res.json()) as {
 			total?: number;
-			objects?: { package?: { name?: string; version?: string; description?: string; date?: string } }[];
+			objects?: {
+				package?: { name?: string; version?: string; description?: string; date?: string };
+				// Already inline on every search hit -- confirmed live against the real registry, no
+				// separate api.npmjs.org/downloads/point/* call needed the way PkgInfo.downloads (one
+				// already-known package) requires. Fetching that per search RESULT would be an N+1
+				// (20 results = 20 extra requests); this is free.
+				downloads?: { weekly?: number; monthly?: number };
+			}[];
 		};
+		const observedAt = new Date().toISOString();
 		const results: Pkg[] = (doc.objects ?? []).flatMap((o) => {
 			const p = o.package;
+			const weekly = boundedCount(o.downloads?.weekly);
+			const monthly = boundedCount(o.downloads?.monthly);
 			return p?.name
 				? [
 						{
@@ -82,6 +92,7 @@ export class HttpRegistry implements Registry {
 							version: boundedString(p.version, 128) ?? "",
 							description: boundedString(p.description, 512),
 							date: boundedString(p.date, 64),
+							...(weekly !== undefined || monthly !== undefined ? { downloads: { weekly, monthly, observedAt } } : {}),
 							packageEvidence: {
 								shape: "keyword-only" as const,
 								verified: false,
@@ -130,6 +141,14 @@ export class HttpRegistry implements Registry {
 			dist?: { unpackedSize?: number; integrity?: string; attestations?: { url?: string; provenance?: unknown } };
 		};
 		const manifestFields = v.pi ? Object.keys(v.pi).filter((key) => ["extensions", "skills", "prompts", "themes"].includes(key)) : [];
+		// Deliberately NOT modified/downloads here -- info() is shared by bulk callers
+		// (build-index.ts, score.ts, setup.ts's resolvePackage, cli.ts, publish.ts), and
+		// build-index.ts's own doc comment documents a real incident: calling downloads() per
+		// package at catalog scale (thousands of entries) hits npm's downloads API 429s within
+		// minutes. Those bulk callers already opt into modifiedAt() explicitly themselves when they
+		// want it, and never call downloads() at all. The single-package, user-facing enrichment
+		// (pkg_info / the Find tab's inspector) lives one layer up, at service.ts's own "package.info"
+		// handler -- the one call site that's genuinely one-package-at-a-time, never bulk.
 		const readme = await this.publishedReadme(encoded);
 		return {
 			name: boundedString(v.name, 214) ?? boundedString(name, 214)!,

package/service/src/setup/setup.ts

@@ -5,6 +5,7 @@ import { fileURLToPath } from "node:url";
 import { Type } from "typebox";
 import { Compile } from "typebox/compile";
 import type { Diagnostic } from "../adoption/check.ts";
+import { assertInstallValidationOk } from "../adoption/install-validation.ts";
 import { npmPackageName, readResolvedIntegrity, readResolvedVersion } from "../packages/installed.ts";
 import type { Installer, Registry } from "../packages/package.ts";
 import { writeJsonAtomic } from "../shared/atomic-json.ts";
@@ -644,9 +645,33 @@ export class SetupManager {
 				(item): item is Extract<SetupOperation, { kind: "install-package" | "update-package" }> =>
 					item.kind === "install-package" || item.kind === "update-package",
 			);
-		for (const operation of packageChanges) {
+		// Batch mode requires all three -- see Installer.validate/installOnly/reresolveDependencyTree's
+		// own doc comments. Any Installer missing even one (e.g. a remote daemon proxy that only ever
+		// implements the plain install()) falls all the way back to today's exact per-package install()
+		// loop below, never a partial mix of the two strategies.
+		const batch = this.installer.validate && this.installer.installOnly && this.installer.reresolveDependencyTree;
+		// Phase 1 (batch mode only): validate every package change CONCURRENTLY. Each call stages
+		// into its own throwaway temp directory with zero shared state between packages -- unlike
+		// the actual `pi install` mutation below, which must stay sequential (a real, confirmed
+		// race: concurrent `pi install` calls against one piHome silently lose entries from BOTH
+		// settings.json and npm/package.json, leaving node_modules with untracked "phantom" installs
+		// a later reresolveDependencyTree() would then prune).
+		const validations = batch
+			? await Promise.allSettled(packageChanges.map((operation) => this.installer.validate!(operation.source)))
+			: undefined;
+		// Phase 2: sequential commit -- unavoidable while `pi install` itself owns unlocked,
+		// shared-file mutation of piHome's settings.json and npm project. In batch mode this calls
+		// installOnly() (no per-package reresolve); otherwise the original install() (validates,
+		// installs, AND re-resolves the whole tree, all per package) exactly as before.
+		for (const [index, operation] of packageChanges.entries()) {
 			try {
-				const output = await this.installer.install(operation.source, { local: operation.scope === "project" });
+				const validation = validations?.[index];
+				if (validation?.status === "rejected") throw validation.reason;
+				if (validation?.status === "fulfilled") assertInstallValidationOk(validation.value);
+				const output =
+					batch && this.installer.installOnly
+						? await this.installer.installOnly(operation.source, { local: operation.scope === "project" })
+						: await this.installer.install(operation.source, { local: operation.scope === "project" });
 				outcomes.push({
 					kind: operation.kind,
 					target: operation.source,
@@ -676,6 +701,29 @@ export class SetupManager {
 				};
 			}
 		}
+		// Phase 3 (batch mode only): re-resolve ONCE for the whole batch instead of once per
+		// package. Only reached once every packageChanges entry has already succeeded above (a
+		// failure already returned early) -- never runs on a partially-applied batch.
+		if (batch && this.installer.reresolveDependencyTree && packageChanges.length > 0) {
+			try {
+				await this.installer.reresolveDependencyTree();
+			} catch (error) {
+				return {
+					ok: false,
+					manifestPath: plan.manifestPath,
+					operations: outcomes,
+					reloadRequired: true,
+					diagnostics: [
+						diagnostic(
+							"SETUP_APPLY_FAILED",
+							"error",
+							"reresolveDependencyTree",
+							`batch dependency re-resolution failed after every package installed/updated successfully: ${error instanceof Error ? error.message : String(error)}`,
+						),
+					],
+				};
+			}
+		}
 		const root = dirname(plan.manifestPath);
 		for (const scope of ["global", "project"] as const) {
 			const changes = plan.operations.filter(

package/service/test/install.test.ts

@@ -15,14 +15,24 @@ import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ExecInstaller } from "../src/packages/install.ts";
+import { createLogger } from "../src/shared/log.ts";
 
 /**
  * A fake `pi` binary: always prints "Updated <source>" and exits 0 (matching
  * real `pi`'s observed behavior for a no-op). When `rewrite` is given, it
  * additionally overwrites that exact package's on-disk version -- letting a
  * test simulate a genuine version change on demand. The rewrite target is
- * baked into the script file itself (not an env var) so it is immune to
- * Bun.spawn's default env snapshot not picking up late process.env writes.
+ * baked into the script file itself (not an env var) rather than read from
+ * process.env at spawn time, keeping these fixtures independent of whichever
+ * way ExecInstaller happens to thread its own env through -- see the
+ * `run()`/`reresolveDependencyTree() thread env explicitly` describe block
+ * below for a dedicated test of that env-threading behavior itself, added
+ * after service/test/perf/multi-install.perf.test.ts caught it live: a
+ * runtime process.env mutation (redirecting Pi's home directory) silently
+ * never reached the spawned `pi`/`npm` children because Bun.spawn's own
+ * default env inheritance doesn't pick up a mutation made after this
+ * process's own startup snapshot -- only an explicit `env: process.env`
+ * option re-reads the current object.
  */
 const roots: string[] = [];
 afterEach(() => {
@@ -206,3 +216,100 @@ describe("ExecInstaller — forces full dependency re-resolution, not just the t
 		await expect(installer.update("npm:plain")).rejects.toThrow(/npm install failed to re-resolve/);
 	});
 });
+
+describe("ExecInstaller — timing instrumentation (see service/test/perf/multi-install.perf.test.ts for a real multi-package measurement)", () => {
+	it("install() logs a validateMs/installMs/reresolveMs/totalMs breakdown, not just a pass/fail result", async () => {
+		const scriptDir = track(mkdtempSync(join(tmpdir(), "packed-exec-bin-")));
+		const bin = writeFakePi(scriptDir);
+		const npmBin = writeFakeNpm(scriptDir, join(scriptDir, "npm.log"));
+		const piHome = writePiHome();
+		const lines: string[] = [];
+		const logger = createLogger("test", (line) => lines.push(line), "debug");
+		const installer = new ExecInstaller(bin, piHome, { validate: async (source) => ({ ok: true, source, extensions: [] }) }, npmBin, logger);
+
+		await installer.install("npm:plain");
+
+		const timing = lines.map((line) => JSON.parse(line)).find((entry) => entry.msg === "install timing");
+		expect(timing).toBeDefined();
+		expect(timing.source).toBe("npm:plain");
+		for (const field of ["validateMs", "installMs", "reresolveMs", "totalMs"]) {
+			expect(typeof timing[field]).toBe("number");
+			expect(timing[field]).toBeGreaterThanOrEqual(0);
+		}
+		// totalMs is the whole call's own wall clock, not just one phase re-labeled --
+		// bounded above by itself plus a small scheduling-noise allowance, never equal to
+		// a single phase alone once every phase is genuinely counted once.
+		expect(timing.totalMs).toBeGreaterThanOrEqual(timing.validateMs + timing.installMs + timing.reresolveMs - 1);
+	});
+
+	it("update() logs an updateMs/reresolveMs/totalMs breakdown", async () => {
+		const scriptDir = track(mkdtempSync(join(tmpdir(), "packed-exec-bin-")));
+		const bin = writeFakePi(scriptDir);
+		const npmBin = writeFakeNpm(scriptDir, join(scriptDir, "npm.log"));
+		const piHome = writePiHome({ plain: "0.5.0" });
+		const lines: string[] = [];
+		const logger = createLogger("test", (line) => lines.push(line), "debug");
+		const installer = new ExecInstaller(bin, piHome, undefined, npmBin, logger);
+
+		await installer.update("npm:plain");
+
+		const timing = lines.map((line) => JSON.parse(line)).find((entry) => entry.msg === "update timing");
+		expect(timing).toBeDefined();
+		expect(timing.source).toBe("npm:plain");
+		for (const field of ["updateMs", "reresolveMs", "totalMs"]) {
+			expect(typeof timing[field]).toBe("number");
+			expect(timing[field]).toBeGreaterThanOrEqual(0);
+		}
+	});
+});
+
+/**
+ * A fake binary that dumps one specific env var's CURRENT value to `logFile` -- proves a
+ * process.env mutation made at runtime (after this test process's own startup, the exact shape
+ * of a caller redirecting Pi's home directory) actually reaches the spawned child, rather than
+ * whatever snapshot Bun.spawn's own default env inheritance captured earlier.
+ */
+function writeEnvDumpBinary(dir: string, name: string, varName: string, logFile: string): string {
+	const script = join(dir, name);
+	writeFileSync(script, ["#!/usr/bin/env bash", `printf '%s' "\$${varName}" > '${logFile}'`, "exit 0"].join("\n"));
+	chmodSync(script, 0o755);
+	return script;
+}
+
+describe("ExecInstaller — run()/reresolveDependencyTree() thread the CURRENT process.env through explicitly", () => {
+	const MARKER = "PACKED_TEST_ENV_MARKER";
+
+	afterEach(() => {
+		delete process.env[MARKER];
+	});
+
+	it("install()'s pi spawn sees an env var set on process.env after this process already started", async () => {
+		const scriptDir = track(mkdtempSync(join(tmpdir(), "packed-exec-env-")));
+		const piLog = join(scriptDir, "pi-env.log");
+		const bin = writeEnvDumpBinary(scriptDir, "fake-pi-env", MARKER, piLog);
+		const npmBin = writeFakeNpm(scriptDir, join(scriptDir, "npm.log"));
+		const piHome = writePiHome();
+		const installer = new ExecInstaller(bin, piHome, { validate: async (source) => ({ ok: true, source, extensions: [] }) }, npmBin);
+
+		// Mutated well after this test process's own startup -- exactly what redirecting Pi's home
+		// via PI_CODING_AGENT_DIR at runtime looks like from ExecInstaller's own point of view.
+		process.env[MARKER] = "set-after-startup";
+		await installer.install("npm:plain");
+
+		expect(readFileSync(piLog, "utf8")).toBe("set-after-startup");
+	});
+
+	it("reresolveDependencyTree()'s npm spawn sees the same runtime env mutation", async () => {
+		const scriptDir = track(mkdtempSync(join(tmpdir(), "packed-exec-env-")));
+		const bin = writeFakePi(scriptDir);
+		const npmLog = join(scriptDir, "npm-env.log");
+		const npmBin = writeEnvDumpBinary(scriptDir, "fake-npm-env", MARKER, npmLog);
+		const piHome = writePiHome();
+		const installer = new ExecInstaller(bin, piHome, { validate: async (source) => ({ ok: true, source, extensions: [] }) }, npmBin);
+
+		process.env[MARKER] = "reresolve-sees-this-too";
+		await installer.install("npm:plain");
+
+		expect(readFileSync(npmLog, "utf8")).toBe("reresolve-sees-this-too");
+	});
+});

package/service/test/npm-metadata-e2e.test.ts

@@ -9,6 +9,9 @@ import { HttpRegistry } from "../src/registry/registry.ts";
 import { createApp } from "../src/daemon/service.ts";
 
 const TOKEN = "e".repeat(64);
+const PUBLISHED_MODIFIED = "2024-03-01T00:00:00.000Z";
+const WEEKLY_DOWNLOADS = 12_345;
+const MONTHLY_DOWNLOADS = 54_321;
 const PUBLISHED_README = `# @danypops/enigma
 
 Encrypted credential vault and supervisor daemon. Holds delegated OAuth/API
@@ -56,17 +59,28 @@ describe("published npm metadata E2E", () => {
 					});
 				}
 				if (url.pathname === "/%40danypops/enigma") {
+					// One response body serves both callers that hit this exact path: HttpRegistry's own
+					// publishedReadme() (Accept: application/json, reads .readme) and modifiedAt() (Accept:
+					// application/vnd.npm.install-v1+json, reads .modified) -- real npm content-negotiates
+					// two different document shapes for the same URL; this fixture keeps it simple by
+					// returning both fields unconditionally, since each caller only ever reads its own.
 					return Response.json({
 						name: "@danypops/enigma",
 						"dist-tags": { latest: "0.22.1" },
 						readme: PUBLISHED_README,
+						modified: PUBLISHED_MODIFIED,
 					});
 				}
+				if (url.pathname === "/downloads/point/last-week/%40danypops/enigma") return Response.json({ downloads: WEEKLY_DOWNLOADS });
+				if (url.pathname === "/downloads/point/last-month/%40danypops/enigma") return Response.json({ downloads: MONTHLY_DOWNLOADS });
 				return new Response("not found", { status: 404 });
 			},
 		});
 		const app = createApp({
-			reg: new HttpRegistry(`http://127.0.0.1:${npmServer.port}`, 20, 0, 1),
+			// downloadsBase points at the SAME fake server as the registry itself -- real npm splits
+			// these across two different hosts (registry.npmjs.org vs api.npmjs.org), but nothing here
+			// cares which host a request lands on, only that it's never the real internet.
+			reg: new HttpRegistry(`http://127.0.0.1:${npmServer.port}`, 20, 0, 1, `http://127.0.0.1:${npmServer.port}`),
 			inst: new NoopInstaller(),
 			token: TOKEN,
 			stateDir,
@@ -80,15 +94,21 @@ describe("published npm metadata E2E", () => {
 		rmSync(stateDir, { recursive: true, force: true });
 	});
 
-	it("preserves an npm-published README through HttpRegistry, daemon RPC, and PackedClient", async () => {
+	it("preserves an npm-published README through HttpRegistry, daemon RPC, and PackedClient, plus the daemon's own package.info release-date/downloads enrichment", async () => {
 		const client = new PackedClient(`http://127.0.0.1:${daemonServer.port}`, TOKEN);
 		const info = await client.info("@danypops/enigma");
 
-		expect(npmRequests).toHaveLength(2);
+		// 2 from HttpRegistry.info() itself (latest + readme) + 1 from the daemon's own
+		// package.info enrichment calling modifiedAt() (same path as readme, different Accept) + 2
+		// from downloads() (last-week, last-month) -- see service.ts's "/info" handler.
+		expect(npmRequests).toHaveLength(5);
 		expect(npmRequests).toEqual(
 			expect.arrayContaining([
 				{ path: "/%40danypops/enigma/latest", accept: "application/json" },
 				{ path: "/%40danypops/enigma", accept: "application/json" },
+				{ path: "/%40danypops/enigma", accept: "application/vnd.npm.install-v1+json" },
+				{ path: "/downloads/point/last-week/%40danypops/enigma", accept: "*/*" },
+				{ path: "/downloads/point/last-month/%40danypops/enigma", accept: "*/*" },
 			]),
 		);
 		expect(info).toMatchObject({
@@ -97,6 +117,8 @@ describe("published npm metadata E2E", () => {
 			license: "MIT",
 			readmeAvailable: true,
 			readme: PUBLISHED_README,
+			modified: PUBLISHED_MODIFIED,
+			downloads: { weekly: WEEKLY_DOWNLOADS, monthly: MONTHLY_DOWNLOADS },
 		});
 	});
 });