@danypops/pi-packed 0.1.7 → 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.7",
+  "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/db.ts

@@ -3,8 +3,48 @@
  * Master-index role: sync_meta (source, time, count, payload checksum —
  * the APT Release / repomd.xml analog). Payload: packages + FTS5 mirror.
  */
-import { Database } from "bun:sqlite";
+// Runtime-detected SQLite backend: bun:sqlite under Bun (CLI, daemon),
+// node:sqlite under Node ≥22.5 (pi's extension host — jiti runs on Node).
+// Both share the better-sqlite3 API shape; transactions are done manually
+// because node:sqlite has no .transaction() helper.
+import { createRequire } from "node:module";
 import { mkdirSync } from "node:fs";
+
+const require_ = createRequire(import.meta.url);
+const IS_BUN = typeof (globalThis as { Bun?: unknown }).Bun !== "undefined";
+const backend = IS_BUN
+	? (require_("bun:sqlite") as typeof import("bun:sqlite"))
+	: (require_("node:sqlite") as unknown as typeof import("bun:sqlite"));
+
+// Constructor + options differ: bun:sqlite exports Database({create}),
+// node:sqlite exports DatabaseSync (creates by default).
+const DatabaseCtor = (
+	"DatabaseSync" in backend ? (backend as { DatabaseSync: unknown }).DatabaseSync : backend.Database
+) as new (path: string, opts?: { create?: boolean }) => Db;
+
+export interface DbStatement {
+	run(...params: unknown[]): { lastInsertRowid: number | bigint };
+	get(...params: unknown[]): unknown;
+	all(...params: unknown[]): unknown[];
+}
+
+export interface Db {
+	exec(sql: string): unknown;
+	prepare(sql: string): DbStatement;
+	close(): void;
+}
+
+function inTransaction<T>(db: Db, fn: () => T): T {
+	db.exec("BEGIN");
+	try {
+		const result = fn();
+		db.exec("COMMIT");
+		return result;
+	} catch (e) {
+		db.exec("ROLLBACK");
+		throw e;
+	}
+}
 import { join } from "node:path";
 import { createHash } from "node:crypto";
 import type { Pkg } from "./ports.ts";
@@ -21,9 +61,9 @@ export function dbPath(dir: string): string {
 	return join(dir, DB_FILE);
 }
 
-export function openDb(path: string): Database {
+export function openDb(path: string): Db {
 	if (path !== ":memory:") mkdirSync(join(path, ".."), { recursive: true });
-	const db = new Database(path, { create: true });
+	const db = IS_BUN ? new DatabaseCtor(path, { create: true }) : new DatabaseCtor(path);
 	db.exec("PRAGMA journal_mode = WAL");
 	db.exec(`CREATE TABLE IF NOT EXISTS packages (
 		name TEXT PRIMARY KEY,
@@ -54,7 +94,7 @@ function payloadHash(pkgs: Pkg[]): string {
 }
 
 /** Atomic full-catalog replace (the mirror write side of `apt update`). */
-export function replaceAll(db: Database, pkgs: Pkg[], source: string): SyncMeta {
+export function replaceAll(db: Db, pkgs: Pkg[], source: string): SyncMeta {
 	const meta: SyncMeta = {
 		source,
 		fetchedAt: new Date().toISOString(),
@@ -65,7 +105,7 @@ export function replaceAll(db: Database, pkgs: Pkg[], source: string): SyncMeta
 	// pages and a package can appear twice in one sync (rowid reuse is fine).
 	const insert = db.prepare("INSERT OR REPLACE INTO packages (name, version, description, date) VALUES (?, ?, ?, ?)");
 	const insertFts = db.prepare("INSERT INTO packages_fts (rowid, name, description) VALUES (?, ?, ?)");
-	db.transaction(() => {
+	inTransaction(db, () => {
 		db.exec("DELETE FROM packages");
 		db.exec("DELETE FROM packages_fts");
 		for (const p of pkgs) {
@@ -77,32 +117,32 @@ export function replaceAll(db: Database, pkgs: Pkg[], source: string): SyncMeta
 				"ON CONFLICT(id) DO UPDATE SET source=excluded.source, fetched_at=excluded.fetched_at, " +
 				"package_count=excluded.package_count, sha256=excluded.sha256",
 		).run(meta.source, meta.fetchedAt, meta.packageCount, meta.sha256);
-	})();
+	});
 	return meta;
 }
 
-export function getSyncMeta(db: Database): SyncMeta | undefined {
+export function getSyncMeta(db: Db): SyncMeta | undefined {
 	return db
-		.query("SELECT source, fetched_at AS fetchedAt, package_count AS packageCount, sha256 FROM sync_meta WHERE id = 1")
+		.prepare("SELECT source, fetched_at AS fetchedAt, package_count AS packageCount, sha256 FROM sync_meta WHERE id = 1")
 		.get() as SyncMeta | undefined;
 }
 
-export function catalogList(db: Database, limit = 0, offset = 0): Pkg[] {
+export function catalogList(db: Db, limit = 0, offset = 0): Pkg[] {
 	const sql =
 		"SELECT name, version, description, date FROM packages ORDER BY name" +
 		(limit > 0 ? ` LIMIT ${Math.floor(limit)} OFFSET ${Math.floor(offset)}` : "");
-	return db.query(sql).all() as Pkg[];
+	return db.prepare(sql).all() as Pkg[];
 }
 
 /** FTS5 over the mirror (the `apt-cache search` analog). Sanitizes user
  * input into AND-joined quoted terms; falls back to LIKE for hostile input. */
-export function searchLocal(db: Database, q: string, limit = 50): Pkg[] {
+export function searchLocal(db: Db, q: string, limit = 50): Pkg[] {
 	const terms = q.trim().split(/\s+/).filter(Boolean);
 	if (terms.length === 0) return [];
 	try {
 		const match = terms.map((t) => `"${t.replaceAll('"', '""')}"*`).join(" ");
 		return db
-			.query(
+			.prepare(
 				`SELECT p.name, p.version, p.description, p.date
 				 FROM packages_fts f JOIN packages p ON p.rowid = f.rowid
 				 WHERE packages_fts MATCH ? ORDER BY rank LIMIT ?`,
@@ -112,13 +152,13 @@ export function searchLocal(db: Database, q: string, limit = 50): Pkg[] {
 		// FTS syntax hostility → substring fallback
 		const like = `%${q}%`;
 		return db
-			.query("SELECT name, version, description, date FROM packages WHERE name LIKE ? OR description LIKE ? ORDER BY name LIMIT ?")
+			.prepare("SELECT name, version, description, date FROM packages WHERE name LIKE ? OR description LIKE ? ORDER BY name LIMIT ?")
 			.all(like, like, limit) as Pkg[];
 	}
 }
 
 /** Latest mirrored version of one package (watcher's lookup). */
-export function latestVersion(db: Database, name: string): string | undefined {
-	const row = db.query("SELECT version FROM packages WHERE name = ?").get(name) as { version: string } | null;
+export function latestVersion(db: Db, name: string): string | undefined {
+	const row = db.prepare("SELECT version FROM packages WHERE name = ?").get(name) as { version: string } | null;
 	return row?.version;
 }

package/src/ports.ts

@@ -53,7 +53,7 @@ export interface UpdateEntry {
 	name: string;
 	installed: string;
 	latest: string;
-	detectedAt: string;
+	detectedAt?: string;
 }
 
 export interface UpdatesSnapshot {

package/src/service.ts

@@ -7,6 +7,7 @@ import { buildSearchQuery, clampLimit } from "./ports.ts";
 import type { Installer, Registry } from "./ports.ts";
 import { TTLCache } from "./cache.ts";
 import { loadUpdates } from "./watcher.ts";
+import { readInstalledPackages, defaultPiHome } from "./installed.ts";
 import { openDb, searchLocal, catalogList, getSyncMeta, dbPath } from "./db.ts";
 import { VERSION, SEARCH_DEFAULT_LIMIT, SEARCH_MAX_LIMIT } from "./constants.ts";
 import { createLogger } from "./log.ts";
@@ -18,10 +19,12 @@ export interface Deps {
 	inst: Installer;
 	token: string;
 	stateDir: string;
+	piHome?: string;
 	cache?: TTLCache;
 }
 
 const SOURCE_RE = /^(npm:[A-Za-z0-9@._/-]+|git:[A-Za-z0-9@:._/-]+|https:\/\/[A-Za-z0-9@:._/?=&%~-]+)$/;
+const NAME_RE = /^(@[A-Za-z0-9._-]+\/)?[A-Za-z0-9._-]+$/;
 
 function json(v: unknown, init?: ResponseInit): Response {
 	return Response.json(v, init);
@@ -73,6 +76,29 @@ export function createApp(deps: Deps): { fetch: (req: Request) => Promise<Respon
 			}
 		}
 
+		if (path === "/installed" && req.method === "GET") {
+			return json(readInstalledPackages(deps.piHome ?? defaultPiHome()));
+		}
+
+		if (path === "/remove" && req.method === "POST") {
+			let name = "";
+			try {
+				const body = (await req.json()) as { name?: unknown };
+				name = String(body.name ?? "");
+			} catch {
+				/* fall through to validation */
+			}
+			if (!NAME_RE.test(name)) {
+				return err(400, "invalid name; want a bare npm package name");
+			}
+			try {
+				const output = await deps.inst.remove(`npm:${name}`);
+				return json({ ok: true, name, output });
+			} catch (e) {
+				return json({ ok: false, name, output: e instanceof Error ? e.message : String(e) });
+			}
+		}
+
 		if (path === "/install" && req.method === "POST") {
 			let source = "";
 			try {