@danypops/pi-packed 0.5.2 → 0.6.0

package/src/registry.ts

@@ -1,141 +0,0 @@
-/**
- * registry.ts — driven adapter: npm registry over HTTP (web-standard fetch).
- * Lean mapping = Facade over npm's verbose package documents.
- */
-import type { Pkg, PkgInfo, Registry, SearchPage } from "./ports.ts";
-import {
-	NPM_REGISTRY_BASE, SEARCH_PAGE_SIZE, RETRY_MAX_ATTEMPTS, RETRY_BASE_DELAY_MS, PAGE_DELAY_MS,
-} from "./constants.ts";
-import { createLogger } from "./log.ts";
-
-const log = createLogger("registry");
-
-/** Upstream etiquette: honor Retry-After on 429, exponential backoff
- * otherwise, give up after RETRY_MAX_ATTEMPTS. */
-async function fetchWithRetry(url: string, init: RequestInit | undefined, baseDelayMs: number): Promise<Response> {
-	let lastErr: Error | undefined;
-	for (let attempt = 1; attempt <= RETRY_MAX_ATTEMPTS; attempt++) {
-		const t0 = Date.now();
-		try {
-			const res = await fetch(url, init);
-			const ms = Date.now() - t0;
-			if (res.status === 429 && attempt < RETRY_MAX_ATTEMPTS) {
-				const ra = res.headers.get("retry-after");
-				const delayMs =
-					ra !== null && Number(ra) > 0
-						? Number(ra) * 1000 // authoritative only when positive
-						: baseDelayMs * 2 ** (attempt - 1); // npm sends 0: use exponential
-				log.warn("429 rate-limited, backing off", { attempt, delayMs, ms, url: url.slice(0, 120) });
-				await Bun.sleep(delayMs);
-				continue;
-			}
-			log.debug("fetch", { status: res.status, ms, attempt, url: url.slice(0, 120) });
-			return res;
-		} catch (e) {
-			lastErr = e instanceof Error ? e : new Error(String(e));
-			log.warn("fetch error, retrying", { attempt, error: lastErr.message, url: url.slice(0, 120) });
-			if (attempt < RETRY_MAX_ATTEMPTS) await Bun.sleep(baseDelayMs * 2 ** (attempt - 1));
-		}
-	}
-	log.error("retry budget exhausted", { attempts: RETRY_MAX_ATTEMPTS, url: url.slice(0, 120) });
-	throw lastErr ?? new Error("retry budget exhausted");
-}
-
-export class HttpRegistry implements Registry {
-	constructor(
-		private base = NPM_REGISTRY_BASE,
-		private pageSize = SEARCH_PAGE_SIZE,
-		private pageDelayMs = PAGE_DELAY_MS,
-		private retryBaseDelayMs = RETRY_BASE_DELAY_MS,
-	) {}
-
-	async search(query: string, limit: number): Promise<SearchPage> {
-		return this.searchPage(query, 0, limit);
-	}
-
-	async searchPage(query: string, from: number, size: number): Promise<SearchPage> {
-		const params = new URLSearchParams({ text: query, size: String(size), from: String(from) });
-		const res = await fetchWithRetry(`${this.base}/-/v1/search?${params}`, undefined, this.retryBaseDelayMs);
-		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 } }[];
-		};
-		const results: Pkg[] = (doc.objects ?? []).flatMap((o) => {
-			const p = o.package;
-			return p?.name
-				? [{ name: p.name, version: p.version ?? "", description: p.description, date: p.date }]
-				: [];
-		});
-		return { results, total: doc.total ?? results.length };
-	}
-
-	async searchAll(query: string): Promise<Pkg[]> {
-		// Map by name: npm's ranking shifts mid-pagination and a package can
-		// appear on two pages — first occurrence wins.
-		const byName = new Map<string, Pkg>();
-		let from = 0;
-		for (;;) {
-			if (from > 0 && this.pageDelayMs > 0) await Bun.sleep(this.pageDelayMs);
-			const { results, total } = await this.searchPage(query, from, this.pageSize);
-			if (results.length === 0 || from >= total) break;
-			for (const p of results) {
-				if (!byName.has(p.name)) byName.set(p.name, p);
-			}
-			from += results.length;
-		}
-		return [...byName.values()];
-	}
-
-	async info(name: string): Promise<PkgInfo> {
-		const res = await fetchWithRetry(
-			`${this.base}/${encodeURIComponent(name).replace("%2F", "/")}`,
-			{ headers: { accept: "application/vnd.npm.install-v1+json" } },
-			this.retryBaseDelayMs,
-		);
-		if (!res.ok) throw new Error(`npm info ${name}: HTTP ${res.status}`);
-		const doc = (await res.json()) as {
-			name?: string;
-			"dist-tags"?: Record<string, string>;
-			versions?: Record<
-				string,
-				{
-					version?: string;
-					description?: string;
-					homepage?: string;
-					license?: unknown;
-					repository?: unknown;
-					keywords?: string[];
-					pi?: Record<string, unknown>;
-					dist?: { unpackedSize?: number };
-				}
-			>;
-			time?: Record<string, string>;
-		};
-		const latest = doc["dist-tags"]?.["latest"] ?? "";
-		const v = doc.versions?.[latest];
-		if (!v) throw new Error(`npm info ${name}: version ${latest} not in document`);
-		return {
-			name: doc.name ?? name,
-			version: v.version ?? latest,
-			description: v.description,
-			homepage: v.homepage,
-			repository: rawToString(v.repository, "url"),
-			license: rawToString(v.license, "type"),
-			keywords: v.keywords,
-			pi: v.pi,
-			modified: doc.time?.["modified"],
-			unpackedSize: v.dist?.unpackedSize,
-		};
-	}
-}
-
-/** npm fields appear as plain string OR object: license: "MIT" | {type:"MIT"}. */
-function rawToString(raw: unknown, objKey: string): string | undefined {
-	if (typeof raw === "string") return raw;
-	if (raw && typeof raw === "object") {
-		const v = (raw as Record<string, unknown>)[objKey];
-		if (typeof v === "string") return v;
-	}
-	return undefined;
-}

package/src/security.ts

@@ -1,95 +0,0 @@
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { SECURITY_FILE } from "./constants.ts";
-
-export const MUTATION_APPROVAL_VALUES = ["always", "never"] as const;
-export type MutationApproval = typeof MUTATION_APPROVAL_VALUES[number];
-
-export const PACKAGE_OPERATIONS = [
-	"search",
-	"info",
-	"installed",
-	"catalog",
-	"updates",
-	"security.read",
-	"mirror",
-	"install",
-	"update",
-	"remove",
-	"security.write",
-] as const;
-export type PackageOperation = typeof PACKAGE_OPERATIONS[number];
-export type PackageOperationClassification = "read" | "maintenance" | "code-execution" | "settings-mutation" | "security-mutation";
-
-export interface SecuritySettings { mutationApproval: MutationApproval }
-export interface SecuritySettingsPort {
-	security(): Promise<SecuritySettings>;
-	setMutationApproval(value: MutationApproval, options?: { approved?: boolean }): Promise<SecuritySettings>;
-}
-
-export interface PackagePermissionDecision {
-	operation: PackageOperation;
-	classification: PackageOperationClassification;
-	approvalRequired: boolean;
-}
-
-export const DEFAULT_SECURITY_SETTINGS: SecuritySettings = { mutationApproval: "always" };
-
-const CLASSIFICATIONS: Record<PackageOperation, PackageOperationClassification> = {
-	search: "read",
-	info: "read",
-	installed: "read",
-	catalog: "read",
-	updates: "read",
-	"security.read": "read",
-	mirror: "maintenance",
-	install: "code-execution",
-	update: "code-execution",
-	remove: "settings-mutation",
-	"security.write": "security-mutation",
-};
-
-export class PackageApprovalRequiredError extends Error {
-	readonly code = "approval_required";
-	constructor(readonly operation: PackageOperation) {
-		super(`approval required for package operation ${operation}`);
-		this.name = "PackageApprovalRequiredError";
-	}
-}
-
-export function packagePermissionDecision(settings: SecuritySettings, operation: PackageOperation): PackagePermissionDecision {
-	const classification = CLASSIFICATIONS[operation];
-	const guarded = classification === "code-execution" || classification === "settings-mutation" || classification === "security-mutation";
-	return { operation, classification, approvalRequired: guarded && settings.mutationApproval === "always" };
-}
-
-export function assertPackagePermission(settings: SecuritySettings, operation: PackageOperation, approved = false): void {
-	if (packagePermissionDecision(settings, operation).approvalRequired && !approved) {
-		throw new PackageApprovalRequiredError(operation);
-	}
-}
-
-export function readSecuritySettings(stateDir: string): SecuritySettings {
-	try {
-		const value = JSON.parse(readFileSync(join(stateDir, SECURITY_FILE), "utf8")) as {
-			mutationApproval?: unknown;
-			installApproval?: unknown;
-		};
-		const stored = value.mutationApproval ?? value.installApproval;
-		return MUTATION_APPROVAL_VALUES.includes(stored as MutationApproval)
-			? { mutationApproval: stored as MutationApproval }
-			: { ...DEFAULT_SECURITY_SETTINGS };
-	} catch {
-		return { ...DEFAULT_SECURITY_SETTINGS };
-	}
-}
-
-export function writeSecuritySettings(stateDir: string, settings: SecuritySettings): SecuritySettings {
-	if (!MUTATION_APPROVAL_VALUES.includes(settings.mutationApproval)) throw new Error("mutationApproval must be always or never");
-	mkdirSync(stateDir, { recursive: true, mode: 0o700 });
-	const target = join(stateDir, SECURITY_FILE);
-	const temporary = `${target}.tmp`;
-	writeFileSync(temporary, `${JSON.stringify(settings)}\n`, { mode: 0o600 });
-	renameSync(temporary, target);
-	return { ...settings };
-}

package/src/service.ts

@@ -1,233 +0,0 @@
-/**
- * service.ts — the hexagon's HTTP driving adapter as a pure Web Standard
- * handler: (Request) → Response. Bun.serve wraps it for the network;
- * tests call it in-process. Same port, two adapters — Cockburn's symmetry.
- */
-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 { SEARCH_DEFAULT_LIMIT, SEARCH_MAX_LIMIT } from "./constants.ts";
-import { VERSION } from "./version.ts";
-import { createLogger } from "./log.ts";
-import {
-	assertPackagePermission,
-	PackageApprovalRequiredError,
-	readSecuritySettings,
-	writeSecuritySettings,
-	type MutationApproval,
-	type PackageOperation,
-} from "./security.ts";
-
-const log = createLogger("service");
-
-export interface Deps {
-	reg: Registry;
-	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);
-}
-
-function err(status: number, msg: string, details: Record<string, unknown> = {}): Response {
-	return json({ error: msg, ...details }, { status });
-}
-
-export function createApp(deps: Deps): { fetch: (req: Request) => Promise<Response> } {
-	const cache = deps.cache ?? new TTLCache();
-
-	function authorize(operation: PackageOperation, approved: boolean): Response | undefined {
-		try {
-			assertPackagePermission(readSecuritySettings(deps.stateDir), operation, approved);
-			return undefined;
-		} catch (error) {
-			if (error instanceof PackageApprovalRequiredError) {
-				return err(403, error.message, { code: error.code, operation: error.operation });
-			}
-			throw error;
-		}
-	}
-
-	async function route(req: Request): Promise<Response> {
-		const url = new URL(req.url);
-		const path = url.pathname;
-
-		if (path === "/health" && req.method === "GET") {
-			return json({ ok: true, version: VERSION });
-		}
-
-		if (path === "/security" && req.method === "GET") {
-			return json(readSecuritySettings(deps.stateDir));
-		}
-
-		if (path === "/security" && req.method === "POST") {
-			let body: { mutationApproval?: unknown; approved?: unknown };
-			try {
-				body = (await req.json()) as typeof body;
-			} catch {
-				return err(400, "invalid security settings JSON");
-			}
-			if (body.mutationApproval !== "always" && body.mutationApproval !== "never") {
-				return err(400, "mutationApproval must be always or never");
-			}
-			const denied = authorize("security.write", body.approved === true);
-			if (denied) return denied;
-			return json(writeSecuritySettings(deps.stateDir, { mutationApproval: body.mutationApproval as MutationApproval }));
-		}
-
-		if (path === "/search" && req.method === "GET") {
-			const q = url.searchParams.get("q") ?? "";
-			const limit = clampLimit(Number(url.searchParams.get("limit")), SEARCH_DEFAULT_LIMIT, SEARCH_MAX_LIMIT);
-			// offline=1: serve from the SQLite mirror (apt-cache search analog)
-			if (url.searchParams.get("offline") === "1") {
-				const db = openDb(dbPath(deps.stateDir));
-				try {
-					const results = searchLocal(db, q, limit);
-					return json({ query: q, total: results.length, results, offline: true });
-				} finally {
-					db.close();
-				}
-			}
-			try {
-				const { results, total } = await deps.reg.search(buildSearchQuery(q), limit);
-				return json({ query: q, total, results });
-			} catch (e) {
-				return err(502, e instanceof Error ? e.message : String(e));
-			}
-		}
-
-		if (path === "/info" && req.method === "GET") {
-			const name = url.searchParams.get("name") ?? "";
-			if (!name) return err(400, "missing name");
-			try {
-				return json(await deps.reg.info(name));
-			} catch (e) {
-				return err(502, e instanceof Error ? e.message : String(e));
-			}
-		}
-
-		if (path === "/installed" && req.method === "GET") {
-			return json(readInstalledPackages(deps.piHome ?? defaultPiHome()));
-		}
-
-		if (path === "/remove" && req.method === "POST") {
-			let name = "";
-			let approved = false;
-			try {
-				const body = (await req.json()) as { name?: unknown; approved?: unknown };
-				name = String(body.name ?? "");
-				approved = body.approved === true;
-			} catch {
-				/* fall through to validation */
-			}
-			if (!NAME_RE.test(name)) {
-				return err(400, "invalid name; want a bare npm package name");
-			}
-			const denied = authorize("remove", approved);
-			if (denied) return denied;
-			try {
-				const output = await deps.inst.remove(`npm:${name}`, { approved });
-				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 = "";
-			let approved = false;
-			try {
-				const body = (await req.json()) as { source?: unknown; approved?: unknown };
-				source = String(body.source ?? "");
-				approved = body.approved === true;
-			} catch {
-				/* fall through to validation */
-			}
-			if (!SOURCE_RE.test(source)) {
-				return err(400, "invalid source; want npm:<pkg>[@ver], git:<host>/<owner>/<repo>[@ref], or https://…");
-			}
-			const denied = authorize("install", approved);
-			if (denied) return denied;
-			try {
-				const output = await deps.inst.install(source, { approved });
-				return json({ ok: true, source, output });
-			} catch (e) {
-				return json({ ok: false, source, output: e instanceof Error ? e.message : String(e) });
-			}
-		}
-
-		if (path === "/update" && req.method === "POST") {
-			let source = "";
-			let approved = false;
-			try {
-				const body = (await req.json()) as { source?: unknown; approved?: unknown };
-				source = String(body.source ?? "");
-				approved = body.approved === true;
-			} catch {
-				/* fall through to validation */
-			}
-			if (!SOURCE_RE.test(source)) {
-				return err(400, "invalid source; want a configured npm:, git:, or https package source");
-			}
-			const denied = authorize("update", approved);
-			if (denied) return denied;
-			try {
-				const outcome = await deps.inst.update(source, { approved });
-				return json({ ok: true, source, ...outcome });
-			} catch (error) {
-				return json({ ok: false, source, output: error instanceof Error ? error.message : String(error), reloadRequired: false });
-			}
-		}
-
-		if (path === "/updates" && req.method === "GET") {
-			const snap = await loadUpdates(deps.stateDir);
-			return json(snap ?? { updates: [] });
-		}
-
-		if (path === "/catalog" && req.method === "GET") {
-			const db = openDb(dbPath(deps.stateDir));
-			try {
-				const meta = getSyncMeta(db);
-				return json({ fetchedAt: meta?.fetchedAt, sha256: meta?.sha256, packages: catalogList(db) });
-			} finally {
-				db.close();
-			}
-		}
-
-		return err(404, "not found");
-	}
-
-	return {
-		async fetch(req: Request): Promise<Response> {
-			const t0 = Date.now();
-			if (req.headers.get("authorization") !== `Bearer ${deps.token}`) {
-				return err(401, "missing or invalid bearer token");
-			}
-			// Cache successful GETs by URI (smart-proxy concern).
-			if (req.method === "GET" && !["/health", "/updates", "/catalog", "/security"].includes(new URL(req.url).pathname)) {
-				const hit = cache.get(req.url);
-				if (hit) {
-					log.debug("request", { path: new URL(req.url).pathname, cache: "hit", ms: Date.now() - t0 });
-					return new Response(hit, { headers: { "content-type": "application/json", "x-cache": "hit" } });
-				}
-				const res = await route(req);
-				if (res.status === 200) cache.set(req.url, await res.clone().text());
-				log.debug("request", { path: new URL(req.url).pathname, status: res.status, cache: "miss", ms: Date.now() - t0 });
-				return res;
-			}
-			const res = await route(req);
-			log.debug("request", { path: new URL(req.url).pathname, status: res.status, ms: Date.now() - t0 });
-			return res;
-		},
-	};
-}

package/src/state.ts

@@ -1,50 +0,0 @@
-/** Daemon state: config dir, bearer token, port file, idle predicate. */
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import { join } from "node:path";
-import { ENV, TOKEN_FILE, PORT_FILE } from "./constants.ts";
-import { randomBytes } from "node:crypto";
-
-export function stateDir(): string {
-	const envHome = process.env[ENV.HOME];
-	if (envHome) return envHome;
-	try {
-		return join(homedir(), ".cache", "pi-packed");
-	} catch {
-		return join(tmpdir(), "pi-packed");
-	}
-}
-
-export function loadOrCreateToken(dir: string): string {
-	const path = join(dir, TOKEN_FILE);
-	try {
-		const tok = readFileSync(path, "utf8").trim();
-		if (tok) return tok;
-	} catch {
-		/* first run */
-	}
-	const tok = randomBytes(16).toString("hex");
-	mkdirSync(dir, { recursive: true });
-	writeFileSync(path, tok + "\n", { mode: 0o600 });
-	return tok;
-}
-
-export function writePort(dir: string, port: number): void {
-	mkdirSync(dir, { recursive: true });
-	writeFileSync(join(dir, PORT_FILE), String(port) + "\n", { mode: 0o600 });
-}
-
-export function idleExpired(lastActiveMs: number, nowMs: number, budgetMs: number): boolean {
-	return nowMs - lastActiveMs > budgetMs;
-}
-
-/** Env knob in seconds → ms. Zero means "disabled" (external lifecycle
- * manager such as systemd owns the process). Garbage → default. */
-export function envMs(key: string, defMs: number): number {
-	const raw = process.env[key];
-	if (raw === undefined) return defMs;
-	const v = Number(raw);
-	if (!Number.isFinite(v) || v < 0) return defMs;
-	if (v === 0) return 0;
-	return v * 1000;
-}

package/src/version.ts

@@ -1,16 +0,0 @@
-import { readFileSync } from "node:fs";
-
-function packageVersion(): string {
-	const manifest = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")) as unknown;
-	if (typeof manifest !== "object" || manifest === null || Array.isArray(manifest)) {
-		throw new Error("pi-packed package manifest must be an object");
-	}
-	const version = (manifest as Record<string, unknown>)["version"];
-	if (typeof version !== "string" || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version)) {
-		throw new Error("pi-packed package manifest has an invalid version");
-	}
-	return version;
-}
-
-/** Runtime package version; package.json is the single release source of truth. */
-export const VERSION = packageVersion();

package/src/watcher.ts

@@ -1,72 +0,0 @@
-/**
- * watcher.ts — event producer #1: version-drift detection.
- * Diffs installed packages against registry dist-tags.latest and persists
- * an event snapshot (event-carried state) for cheap consumer reads.
- */
-import { writeFile, readFile, mkdir } from "node:fs/promises";
-import { join } from "node:path";
-import { UPDATES_FILE } from "./constants.ts";
-import { createLogger } from "./log.ts";
-
-const log = createLogger("watcher");
-import type { InstalledPkg, UpdateEntry, UpdatesSnapshot } from "./ports.ts";
-
-function updatesPath(dir: string): string {
-	return join(dir, UPDATES_FILE);
-}
-
-export async function saveUpdates(dir: string, snap: UpdatesSnapshot): Promise<void> {
-	await mkdir(dir, { recursive: true });
-	await writeFile(updatesPath(dir), JSON.stringify(snap), { mode: 0o600 });
-}
-
-export async function loadUpdates(dir: string): Promise<UpdatesSnapshot | undefined> {
-	try {
-		return JSON.parse(await readFile(updatesPath(dir), "utf8")) as UpdatesSnapshot;
-	} catch {
-		return undefined;
-	}
-}
-
-/** Pure diff against the local mirror (apt list --upgradable semantics):
- * drift = mirrored latest ≠ what we have. The mirror is refreshed by
- * catalogSync; updates are computed offline, exactly like APT. */
-export function checkUpdates(latestOf: (name: string) => string | undefined, installed: InstalledPkg[]): UpdateEntry[] {
-	const now = new Date().toISOString();
-	const updates: UpdateEntry[] = [];
-	for (const p of installed) {
-		const have = p.installed || p.pinned;
-		if (!have) continue;
-		const latest = latestOf(p.name);
-		if (latest && latest !== have) {
-			updates.push({ name: p.name, installed: have, latest, detectedAt: now });
-		}
-	}
-	return updates;
-}
-
-export interface WatcherOptions {
-	intervalMs: number;
-	onError?: (e: unknown) => void;
-}
-
-/** Producer loop: immediate check, then on a timer. Returns a stop function. */
-export function startWatcher(
-	latestOf: (name: string) => string | undefined,
-	stateDir: string,
-	readInstalled: () => InstalledPkg[],
-	opts: WatcherOptions,
-): () => void {
-	async function check(): Promise<void> {
-		try {
-			const updates = checkUpdates(latestOf, readInstalled());
-			await saveUpdates(stateDir, { checkedAt: new Date().toISOString(), updates });
-			log.info("updates check", { updates: updates.length });
-		} catch (e) {
-			opts.onError?.(e);
-		}
-	}
-	void check();
-	const timer = setInterval(() => void check(), opts.intervalMs);
-	return () => clearInterval(timer);
-}