@danypops/pi-packed 0.1.0 → 0.2.0

package/extension/src/index.ts

@@ -11,31 +11,32 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerTools } from "./tools.js";
 import { showPackages } from "./tui.js";
-import { runPacked } from "./packed.js";
+import { createNatives } from "./packed.js";
 import { formatUpdateNotice } from "./model.js";
-import type { UpdatesSnapshot } from "./packed.js";
 
-export default function (pi: ExtensionAPI) {
-	registerTools(pi);
+// Async factory (pi awaits it): dynamic imports load the service library
+// in-process — the native pattern, no subprocess.
+export default async function (pi: ExtensionAPI) {
+	const natives = await createNatives();
+	registerTools(pi, natives);
 
 	pi.registerCommand("packages", {
 		description: "Browse and manage installed Pi packages (pi-packed)",
 		handler: async (_args, ctx) => {
-			await showPackages(ctx);
+			await showPackages(ctx, natives);
 		},
 	});
 
-	// The watcher (daemon side) produces the snapshot; the seam consumes it
-	// on Pi's own lifecycle event — that's the whole event-driven story.
+	// Update check against the local mirror, on Pi's own lifecycle event.
 	pi.on("session_start", async (_event, ctx) => {
 		if (!ctx.hasUI) return;
 		try {
-			const snap = await runPacked<UpdatesSnapshot>(["updates", "--cached"], 3_000);
-			if (snap.updates?.length) {
-				ctx.ui.notify(`${formatUpdateNotice(snap.updates)} — /packages to review`, "info");
+			const updates = await natives.updates();
+			if (updates.length) {
+				ctx.ui.notify(`${formatUpdateNotice(updates)} — /packages to review`, "info");
 			}
 		} catch {
-			// packed missing or daemon down — stay silent, never block startup.
+			// mirror missing or unreadable — stay silent, never block startup.
 		}
 	});
 }

package/extension/src/packed.ts

@@ -1,90 +1,79 @@
 /**
- * packed.ts — the ONLY place the seam touches the service side.
- * Thin exec wrapper: every call is `bun <pi-packed>/src/cli.ts <cmd>`.
- * No registry, daemon, or npm knowledge lives here.
+ * packed.ts — native library client. The seam imports the pi-packed service
+ * modules IN-PROCESS (web-spider's pattern: dynamic import() bypasses jiti's
+ * CJS interop, which can drop class constructors for "type":"module" packages).
+ *
+ * The SQLite mirror is the shared substrate (WAL: the daemon writes, we read
+ * concurrently). The daemon remains the background producer; the seam works
+ * even with the daemon down. No subprocess, no token/port files.
  */
-import { execFile } from "node:child_process";
-
-export interface InstalledPkg {
-	name: string;
-	pinned?: string;
-	installed?: string;
-}
-
-export interface UpdateEntry {
-	name: string;
-	installed: string;
-	latest: string;
-	detectedAt?: string;
-}
-
-export interface UpdatesSnapshot {
-	checkedAt?: string;
-	updates: UpdateEntry[];
-}
-
-export interface SearchResult {
-	name: string;
-	version: string;
-	description?: string;
-	date?: string;
-}
+import type { Db } from "../../src/db.ts";
+import type { InstalledPkg, Pkg, PkgInfo, UpdateEntry } from "../../src/ports.ts";
 
+export type { InstalledPkg, UpdateEntry };
+export type PackageInfo = PkgInfo;
 export interface SearchResponse {
 	query: string;
 	total: number;
-	results: SearchResult[];
-}
-
-export interface PackageInfo {
-	name: string;
-	version: string;
-	description?: string;
-	homepage?: string;
-	repository?: string;
-	license?: string;
-	keywords?: string[];
-	pi?: Record<string, unknown>;
-	modified?: string;
-	unpackedSize?: number;
+	results: Pkg[];
 }
 
-/** Path to the pi-packed CLI entry (resolved relative to this file). */
-export function cliPath(): string {
-	if (process.env["PACKED_CLI"]) return process.env["PACKED_CLI"];
-	return new URL("../../src/cli.ts", import.meta.url).pathname;
+export interface Natives {
+	search(query: string, limit: number): Promise<SearchResponse>;
+	searchOffline(query: string, limit: number): Promise<SearchResponse>;
+	info(name: string): Promise<PackageInfo>;
+	installed(): Promise<InstalledPkg[]>;
+	updates(): Promise<UpdateEntry[]>;
+	install(source: string): Promise<string>;
+	remove(name: string): Promise<string>;
 }
 
-export function packedCmd(): { bin: string; prefix: string[] } {
-	if (process.env["PACKED_BIN"]) return { bin: process.env["PACKED_BIN"], prefix: [] };
-	return { bin: process.env["PACKED_BUN"] ?? "bun", prefix: [cliPath()] };
-}
+export async function createNatives(): Promise<Natives> {
+	const [dbMod, regMod, instMod, watchMod, execMod, stateMod, portsMod] = await Promise.all([
+		import("../../src/db.ts"),
+		import("../../src/registry.ts"),
+		import("../../src/installed.ts"),
+		import("../../src/watcher.ts"),
+		import("../../src/install.ts"),
+		import("../../src/state.ts"),
+		import("../../src/ports.ts"),
+	]);
 
-function exec(cmd: string, args: string[], timeoutMs: number): Promise<{ stdout: string; stderr: string }> {
-	return new Promise((resolve, reject) => {
-		execFile(cmd, args, { timeout: timeoutMs, maxBuffer: 16 * 1024 * 1024 }, (err, stdout, stderr) => {
-			if (err) {
-				reject(new Error(stderr?.trim() || err.message));
-				return;
-			}
-			resolve({ stdout, stderr });
-		});
-	});
-}
+	const reg = new regMod.HttpRegistry();
+	const inst = new execMod.ExecInstaller();
 
-export async function runPacked<T>(args: string[], timeoutMs = 15_000): Promise<T> {
-	const { bin, prefix } = packedCmd();
-	const { stdout } = await exec(bin, [...prefix, ...args, "--json"], timeoutMs);
-	try {
-		return JSON.parse(stdout) as T;
-	} catch {
-		throw new Error(`packed ${args[0]}: invalid JSON: ${stdout.slice(0, 200)}`);
+	// Per-call open/close: lifecycle-clean (no held handles, safe with the
+	// daemon writing concurrently under WAL).
+	function withDb<T>(fn: (db: Db) => T): T {
+		const db = dbMod.openDb(dbMod.dbPath(stateMod.stateDir()));
+		try {
+			return fn(db);
+		} finally {
+			db.close();
+		}
 	}
-}
 
-/** Text output variant for install/remove (human-readable pi output). */
-export async function runPackedText(args: string[], timeoutMs = 180_000): Promise<string> {
-	const { bin, prefix } = packedCmd();
-	const { stdout, stderr } = await exec(bin, [...prefix, ...args], timeoutMs);
-	return [stdout.trim(), stderr.trim()].filter(Boolean).join("\n");
+	return {
+		async search(query, limit) {
+			const { results, total } = await reg.search(portsMod.buildSearchQuery(query), limit);
+			return { query, total, results };
+		},
+		async searchOffline(query, limit) {
+			const results = withDb((db) => dbMod.searchLocal(db, query, limit));
+			return { query, total: results.length, results };
+		},
+		info: (name) => reg.info(name),
+		installed: () => Promise.resolve(instMod.readInstalledPackages(instMod.defaultPiHome())),
+		updates: () =>
+			Promise.resolve(
+				withDb((db) =>
+					watchMod.checkUpdates(
+						(name) => dbMod.latestVersion(db, name),
+						instMod.readInstalledPackages(instMod.defaultPiHome()),
+					),
+				),
+			),
+		install: (source) => inst.install(source),
+		remove: (name) => inst.remove(`npm:${name}`),
+	};
 }

package/extension/src/tools.ts

@@ -4,14 +4,13 @@
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { runPacked, runPackedText } from "./packed.js";
-import type { PackageInfo, SearchResponse } from "./packed.js";
+import type { Natives } from "./packed.js";
 
 function text(t: string, details: Record<string, unknown> = {}) {
 	return { content: [{ type: "text" as const, text: t }], details };
 }
 
-export function registerTools(pi: ExtensionAPI): void {
+export function registerTools(pi: ExtensionAPI, natives: Natives): void {
 	pi.registerTool({
 		name: "pkg_search",
 		label: "Pi Package Search",
@@ -24,9 +23,7 @@ export function registerTools(pi: ExtensionAPI): void {
 		}),
 		async execute(_id, params, _signal, _onUpdate, _ctx) {
 			try {
-				const r = await runPacked<SearchResponse>(
-					["search", params.query, "--limit", String(params.limit ?? 10)],
-				);
+				const r = await natives.search(params.query, params.limit ?? 10);
 				if (r.results.length === 0) return text(`No Pi packages found for "${params.query}".`);
 				const lines = r.results.map(
 					(p, i) => `${i + 1}. ${p.name}@${p.version}\n   ${p.description ?? ""}`,
@@ -52,7 +49,7 @@ export function registerTools(pi: ExtensionAPI): void {
 		}),
 		async execute(_id, params, _signal, _onUpdate, _ctx) {
 			try {
-				const info = await runPacked<PackageInfo>(["info", params.name]);
+				const info = await natives.info(params.name);
 				const lines = [
 					`${info.name}@${info.version}`,
 					info.description ?? "",
@@ -88,7 +85,7 @@ export function registerTools(pi: ExtensionAPI): void {
 			);
 			if (!ok) return text("Install cancelled by user.");
 			try {
-				const out = await runPackedText(["install", params.source]);
+				const out = await natives.install(params.source);
 				return text(out || `Installed ${params.source}. Reload with /reload to activate.`);
 			} catch (e) {
 				return text(`install failed: ${e instanceof Error ? e.message : e}`);

package/extension/src/tui.ts

@@ -9,33 +9,32 @@ import { DynamicBorder, rawKeyHint } from "@earendil-works/pi-coding-agent";
 import { Container, Input, Spacer, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { filterRows, mergeRows, nextMode, visibleRows } from "./model.js";
 import type { Row, ViewMode } from "./model.js";
-import { runPacked, runPackedText } from "./packed.js";
-import type { InstalledPkg, UpdatesSnapshot } from "./packed.js";
+import type { Natives } from "./packed.js";
 
 interface PanelAction {
 	type: "menu" | "refresh";
 	row?: Row;
 }
 
-async function loadRows(): Promise<{ rows: Row[]; error?: string }> {
+async function loadRows(natives: Natives): Promise<{ rows: Row[]; error?: string }> {
 	try {
-		const [installed, snap] = await Promise.all([
-			runPacked<InstalledPkg[]>(["installed"]),
-			runPacked<UpdatesSnapshot>(["updates", "--cached"], 5_000).catch(() => ({ updates: [] }) as UpdatesSnapshot),
+		const [installed, updates] = await Promise.all([
+			natives.installed(),
+			natives.updates().catch(() => []),
 		]);
-		return { rows: mergeRows(installed, snap.updates ?? []) };
+		return { rows: mergeRows(installed, updates) };
 	} catch (e) {
 		return { rows: [], error: e instanceof Error ? e.message : String(e) };
 	}
 }
 
-export async function showPackages(ctx: ExtensionCommandContext): Promise<void> {
+export async function showPackages(ctx: ExtensionCommandContext, natives: Natives): Promise<void> {
 	if (!ctx.hasUI) {
 		ctx.ui.notify("/packages requires interactive mode", "warning");
 		return;
 	}
 
-	let { rows, error } = await loadRows();
+	let { rows, error } = await loadRows(natives);
 	if (error) {
 		ctx.ui.notify(`packed unavailable: ${error}`, "error");
 		return;
@@ -47,7 +46,7 @@ export async function showPackages(ctx: ExtensionCommandContext): Promise<void>
 		if (!action) return; // closed
 
 		if (action.type === "refresh") {
-			({ rows, error } = await loadRows());
+			({ rows, error } = await loadRows(natives));
 			if (error) ctx.ui.notify(`refresh failed: ${error}`, "error");
 			continue;
 		}
@@ -67,7 +66,7 @@ export async function showPackages(ctx: ExtensionCommandContext): Promise<void>
 		if (choice?.startsWith("Update")) {
 			ctx.ui.notify(`Updating ${row.name}…`, "info");
 			try {
-				await runPackedText(["install", `npm:${row.name}@${row.latest}`]);
+				await natives.install(`npm:${row.name}@${row.latest}`);
 				ctx.ui.notify(`Updated ${row.name} to ${row.latest} (takes effect after /reload)`, "info");
 				row.version = row.latest ?? row.version;
 				row.hasUpdate = false;
@@ -78,7 +77,7 @@ export async function showPackages(ctx: ExtensionCommandContext): Promise<void>
 			const sure = await ctx.ui.confirm("Remove package", `pi remove npm:${row.name}?`);
 			if (sure) {
 				try {
-					await runPackedText(["remove", row.name]);
+					await natives.remove(row.name);
 					ctx.ui.notify(`Removed ${row.name}`, "info");
 					rows = rows.filter((r) => r.name !== row.name);
 				} catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-packed",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Package service for the Pi agent: search/info/install/updates + /packages TUI, backed by a long-running Bun service",
   "type": "module",
   "keywords": [

package/src/cache.ts

@@ -1,7 +1,9 @@
 /** TTLCache — the smart-proxy concern, nothing more. */
+import { CACHE_TTL_MS } from "./constants.ts";
+
 export class TTLCache {
 	private m = new Map<string, { body: string; expires: number }>();
-	constructor(private ttlMs = 5 * 60_000) {}
+	constructor(private ttlMs = CACHE_TTL_MS) {}
 
 	get(key: string): string | undefined {
 		const e = this.m.get(key);

package/src/catalog.ts

@@ -1,44 +1,45 @@
 /**
- * catalog.ts — event producer #2: bulk snapshot of every pi package.
- * npm's search API has no ETag/conditional requests (CDN max-age only),
- * so freshness is TTL-based: resync on serve start + interval.
+ * catalog.ts — the sync pipeline (apt update / pkg update analog).
+ * Paginates the upstream registry into the local SQLite mirror and records
+ * sync metadata (the Release/repomd checksum role) in sync_meta.
  */
-import { writeFile, readFile, mkdir } from "node:fs/promises";
-import { join } from "node:path";
 import type { Pkg, Registry } from "./ports.ts";
+import { PI_PACKAGE_KEYWORD } from "./constants.ts";
+import { openDb, replaceAll, getSyncMeta, dbPath } from "./db.ts";
+import { createLogger } from "./log.ts";
 
-export interface CatalogSnapshot {
-	fetchedAt: string;
-	packages: Pkg[];
-}
-
-function catalogPath(dir: string): string {
-	return join(dir, "catalog.json");
-}
+const log = createLogger("catalog");
+import type { SyncMeta } from "./db.ts";
 
-export async function saveCatalog(dir: string, snap: CatalogSnapshot): Promise<void> {
-	await mkdir(dir, { recursive: true });
-	await writeFile(catalogPath(dir), JSON.stringify(snap), { mode: 0o600 });
+export interface CatalogStatus {
+	stale: boolean;
+	meta?: SyncMeta;
 }
 
-export async function loadCatalog(dir: string): Promise<CatalogSnapshot | undefined> {
+export function catalogStatus(dir: string, ttlMs: number): CatalogStatus {
+	const db = openDb(dbPath(dir));
 	try {
-		return JSON.parse(await readFile(catalogPath(dir), "utf8")) as CatalogSnapshot;
-	} catch {
-		return undefined;
+		const meta = getSyncMeta(db);
+		if (!meta) return { stale: true };
+		return { stale: Date.now() - Date.parse(meta.fetchedAt) > ttlMs, meta };
+	} finally {
+		db.close();
 	}
 }
 
-export function catalogStale(snap: CatalogSnapshot | undefined, ttlMs: number): boolean {
-	if (!snap?.fetchedAt) return true;
-	return Date.now() - Date.parse(snap.fetchedAt) > ttlMs;
-}
-
-/** Full sync: paginate the whole keyword universe into a lean snapshot. */
-export async function syncCatalog(reg: Registry, dir: string, query = "keywords:pi-package"): Promise<number> {
+/** Full mirror sync: upstream pages → atomic SQLite replace. */
+export async function syncCatalog(reg: Registry, dir: string, query: string = PI_PACKAGE_KEYWORD): Promise<number> {
+	const t0 = Date.now();
+	log.info("mirror sync started", { query });
 	const packages = await reg.searchAll(query);
-	await saveCatalog(dir, { fetchedAt: new Date().toISOString(), packages });
-	return packages.length;
+	const db = openDb(dbPath(dir));
+	try {
+		replaceAll(db, packages, "npm:" + query);
+		log.info("mirror sync complete", { packages: packages.length, ms: Date.now() - t0 });
+		return packages.length;
+	} finally {
+		db.close();
+	}
 }
 
 export function startCatalogSync(
@@ -49,9 +50,9 @@ export function startCatalogSync(
 ): () => void {
 	async function sync(): Promise<void> {
 		try {
-			if (catalogStale(await loadCatalog(dir), ttlMs)) {
+			if (catalogStatus(dir, ttlMs).stale) {
 				const n = await syncCatalog(reg, dir);
-				console.error(`[packed] catalog synced: ${n} packages`);
+				log.info("scheduled sync complete", { packages: n });
 			}
 		} catch (e) {
 			onError?.(e);

package/src/cli.ts

@@ -7,20 +7,25 @@
 import { buildSearchQuery, clampLimit } from "./ports.ts";
 import type { Installer, Registry } from "./ports.ts";
 import { readInstalledPackages } from "./installed.ts";
-import { checkUpdates, loadUpdates } from "./watcher.ts";
-import { loadCatalog } from "./catalog.ts";
+import { checkUpdates } from "./watcher.ts";
+import { syncCatalog } from "./catalog.ts";
+import { openDb, searchLocal, catalogList, getSyncMeta, latestVersion, dbPath } from "./db.ts";
 import { NAME_RE } from "./install.ts";
+import {
+	VERSION, SEARCH_DEFAULT_LIMIT, SEARCH_MAX_LIMIT, NPM_REGISTRY_BASE, SEARCH_PAGE_SIZE, MIRROR_PAGE_DELAY_MS,
+} from "./constants.ts";
 
 const SOURCE_RE = /^(npm:[A-Za-z0-9@._/-]+|git:[A-Za-z0-9@:._/-]+|https:\/\/[A-Za-z0-9@:._/?=&%~-]+)$/;
 
 const USAGE = `packed — package service for the Pi agent
 
 usage:
-  packed search <query> [--limit N] [--json]   search pi packages on npm
+  packed search <query> [--offline] [--json]   search npm (or the local mirror with --offline)
   packed info <name> [--json]                  package details
-  packed updates [--cached] [--json]           available updates (cached = daemon snapshot)
+  packed updates [--json]                      updates per the local mirror
+  packed mirror [--json]                       sync upstream into the local SQLite index
   packed installed [--json]                    installed pi packages
-  packed catalog [--json]                      full pi-package catalog snapshot
+  packed catalog [--json]                      local package index (apt-cache stats)
   packed install <source>                      pi install npm:|git:|https://…
   packed remove <name>                         remove by bare npm name
   packed serve                                 run the long-running daemon
@@ -46,17 +51,19 @@ interface Flags {
 	json: boolean;
 	limit: number;
 	cached: boolean;
+	offline: boolean;
 }
 
 function parseFlags(rest: string[]): { flags: Flags; pos: string[] } {
-	const flags: Flags = { json: false, limit: 10, cached: false };
+	const flags: Flags = { json: false, limit: SEARCH_DEFAULT_LIMIT, cached: false, offline: false };
 	const pos: string[] = [];
 	for (let i = 0; i < rest.length; i++) {
 		const a = rest[i]!;
 		if (a === "--json") flags.json = true;
 		else if (a === "--cached") flags.cached = true;
-		else if (a === "--limit" && i + 1 < rest.length) flags.limit = Number(rest[++i]) || 10;
-		else if (a.startsWith("--limit=")) flags.limit = Number(a.slice(8)) || 10;
+		else if (a === "--offline") flags.offline = true;
+		else if (a === "--limit" && i + 1 < rest.length) flags.limit = Number(rest[++i]) || SEARCH_DEFAULT_LIMIT;
+		else if (a.startsWith("--limit=")) flags.limit = Number(a.slice(8)) || SEARCH_DEFAULT_LIMIT;
 		else pos.push(a);
 	}
 	return { flags, pos };
@@ -70,11 +77,26 @@ const usageErr = (out: string): CliResult => ({ code: 2, out });
 
 const commands: Record<string, { usage: string; run: Command }> = {
 	search: {
-		usage: "packed search <query> [--limit N] [--json]",
+		usage: "packed search <query> [--offline] [--limit N] [--json]",
 		async run(_rest, d, flags, pos) {
 			const q = pos[0];
 			if (!q) return usageErr(`usage: ${commands["search"]!.usage}\n`);
-			const { results, total } = await d.reg.search(buildSearchQuery(q), clampLimit(flags.limit, 10, 50));
+			const limit = clampLimit(flags.limit, SEARCH_DEFAULT_LIMIT, SEARCH_MAX_LIMIT);
+			// --offline: query the SQLite mirror only (apt-cache search analog)
+			if (flags.offline) {
+				const db = openDb(dbPath(d.stateDir));
+				try {
+					const results = searchLocal(db, q, limit);
+					if (flags.json) return ok(JSON.stringify({ query: q, total: results.length, results, offline: true }) + "\n");
+					if (results.length === 0) return ok(`no mirrored packages match "${q}" (run: packed mirror)\n`);
+					let out = `${results.length} mirrored package(s):\n\n`;
+					for (const p of results) out += `  ${p.name}@${p.version}\n    ${p.description ?? ""}\n`;
+					return ok(out);
+				} finally {
+					db.close();
+				}
+			}
+			const { results, total } = await d.reg.search(buildSearchQuery(q), limit);
 			if (flags.json) return ok(JSON.stringify({ query: q, total, results }) + "\n");
 			if (results.length === 0) return ok(`no pi packages found for "${q}"\n`);
 			let out = `${total} package(s) (showing ${results.length}):\n\n`;
@@ -83,6 +105,15 @@ const commands: Record<string, { usage: string; run: Command }> = {
 		},
 	},
 
+	mirror: {
+		usage: "packed mirror [--json]  (sync the upstream registry into the local SQLite index — the apt update analog)",
+		async run(_rest, d, flags) {
+			const n = await syncCatalog(d.reg, d.stateDir);
+			if (flags.json) return ok(JSON.stringify({ synced: n }) + "\n");
+			return ok(`mirrored ${n} packages into the local index\n`);
+		},
+	},
+
 	info: {
 		usage: "packed info <name> [--json]",
 		async run(_rest, d, flags, pos) {
@@ -98,18 +129,19 @@ const commands: Record<string, { usage: string; run: Command }> = {
 	},
 
 	updates: {
-		usage: "packed updates [--cached] [--json]",
+		usage: "packed updates [--json]  (from the local mirror — run `packed mirror` first)",
 		async run(_rest, d, flags) {
+			const db = openDb(dbPath(d.stateDir));
 			let updates;
-			if (flags.cached) {
-				updates = (await loadUpdates(d.stateDir))?.updates ?? [];
-			} else {
-				updates = await checkUpdates(d.reg, readInstalledPackages(d.piHome));
+			try {
+				updates = checkUpdates((name) => latestVersion(db, name), readInstalledPackages(d.piHome));
+			} finally {
+				db.close();
 			}
 			if (flags.json) {
 				return ok(JSON.stringify({ checkedAt: new Date().toISOString(), updates }) + "\n");
 			}
-			if (updates.length === 0) return ok("all pi packages up to date\n");
+			if (updates.length === 0) return ok("all pi packages up to date (per the local mirror)\n");
 			let out = `${updates.length} update(s) available:\n\n`;
 			for (const u of updates) out += `  ${u.name}  ${u.installed} → ${u.latest}\n`;
 			return ok(out + "\nrun: pi update --extensions\n");
@@ -128,12 +160,21 @@ const commands: Record<string, { usage: string; run: Command }> = {
 	catalog: {
 		usage: "packed catalog [--json]",
 		async run(_rest, d, flags) {
-			const snap = await loadCatalog(d.stateDir);
-			const packages = snap?.packages ?? [];
-			if (flags.json) return ok(JSON.stringify(snap ?? { packages: [] }) + "\n");
-			let out = `${packages.length} packages in catalog (fetched ${snap?.fetchedAt ?? "never"})\n\n`;
-			for (const p of packages.slice(0, 50)) out += `  ${p.name}@${p.version}\n`;
-			return ok(out);
+			const db = openDb(dbPath(d.stateDir));
+			try {
+				const meta = getSyncMeta(db);
+				const packages = catalogList(db);
+				if (flags.json) {
+					return ok(JSON.stringify({ fetchedAt: meta?.fetchedAt, sha256: meta?.sha256, packages }) + "\n");
+				}
+				let out = `${packages.length} packages in the local index`;
+				if (meta) out += ` (synced ${meta.fetchedAt}, sha256:${meta.sha256.slice(0, 12)}…)`;
+				out += "\n\n";
+				for (const p of packages.slice(0, 50)) out += `  ${p.name}@${p.version}\n`;
+				return ok(out);
+			} finally {
+				db.close();
+			}
 		},
 	},
 
@@ -175,7 +216,7 @@ const commands: Record<string, { usage: string; run: Command }> = {
 	version: {
 		usage: "packed version",
 		async run() {
-			return ok("0.1.0\n");
+			return ok(VERSION + "\n");
 		},
 	},
 };
@@ -226,7 +267,11 @@ if (import.meta.main) {
 		const { resolveRegistry } = await import("./client.ts");
 		const { ExecInstaller } = await import("./install.ts");
 		const dir = stateDir();
-		const reg = await resolveRegistry(dir, "https://registry.npmjs.org");
+		// mirror talks to UPSTREAM, not the daemon cache — apt update semantics.
+		const reg =
+			args[0] === "mirror"
+				? new (await import("./registry.ts")).HttpRegistry(NPM_REGISTRY_BASE, SEARCH_PAGE_SIZE, MIRROR_PAGE_DELAY_MS)
+				: await resolveRegistry(dir, NPM_REGISTRY_BASE);
 		const { code, out } = await cliRun(args, {
 			reg,
 			inst: new ExecInstaller(),

package/src/client.ts

@@ -7,6 +7,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import type { PkgInfo, Registry, SearchPage } from "./ports.ts";
 import { HttpRegistry } from "./registry.ts";
+import { DAEMON_HOST, PROBE_TIMEOUT_MS, REGISTRY_FETCH_TIMEOUT_MS, PORT_FILE, TOKEN_FILE } from "./constants.ts";
 
 export class DaemonRegistry implements Registry {
 	constructor(
@@ -17,7 +18,7 @@ export class DaemonRegistry implements Registry {
 	private async get<T>(path: string): Promise<T> {
 		const res = await fetch(`${this.base}${path}`, {
 			headers: { authorization: `Bearer ${this.token}` },
-			signal: AbortSignal.timeout(15_000),
+			signal: AbortSignal.timeout(REGISTRY_FETCH_TIMEOUT_MS),
 		});
 		if (!res.ok) throw new Error(`daemon HTTP ${res.status}`);
 		return (await res.json()) as T;
@@ -55,16 +56,16 @@ export async function probe(dir: string): Promise<DaemonHandle | undefined> {
 	let port: string;
 	let token: string;
 	try {
-		port = readFileSync(join(dir, "port"), "utf8").trim();
-		token = readFileSync(join(dir, "token"), "utf8").trim();
+		port = readFileSync(join(dir, PORT_FILE), "utf8").trim();
+		token = readFileSync(join(dir, TOKEN_FILE), "utf8").trim();
 	} catch {
 		return undefined;
 	}
-	const base = `http://127.0.0.1:${port}`;
+	const base = `http://${DAEMON_HOST}:${port}`;
 	try {
 		const res = await fetch(`${base}/health`, {
 			headers: { authorization: `Bearer ${token}` },
-			signal: AbortSignal.timeout(800),
+			signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
 		});
 		if (res.ok) return { base, token };
 	} catch {