@danypops/pi-packed 0.1.0

package/src/service.ts

@@ -0,0 +1,112 @@
+/**
+ * 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 { loadCatalog } from "./catalog.ts";
+
+export interface Deps {
+	reg: Registry;
+	inst: Installer;
+	token: string;
+	stateDir: string;
+	cache?: TTLCache;
+}
+
+const SOURCE_RE = /^(npm:[A-Za-z0-9@._/-]+|git:[A-Za-z0-9@:._/-]+|https:\/\/[A-Za-z0-9@:._/?=&%~-]+)$/;
+
+function json(v: unknown, init?: ResponseInit): Response {
+	return Response.json(v, init);
+}
+
+function err(status: number, msg: string): Response {
+	return json({ error: msg }, { status });
+}
+
+export function createApp(deps: Deps): { fetch: (req: Request) => Promise<Response> } {
+	const cache = deps.cache ?? new TTLCache();
+
+	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: "0.1.0" });
+		}
+
+		if (path === "/search" && req.method === "GET") {
+			const q = url.searchParams.get("q") ?? "";
+			const limit = clampLimit(Number(url.searchParams.get("limit")), 10, 50);
+			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 === "/install" && req.method === "POST") {
+			let source = "";
+			try {
+				const body = (await req.json()) as { source?: unknown };
+				source = String(body.source ?? "");
+			} 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://…");
+			}
+			try {
+				const output = await deps.inst.install(source);
+				return json({ ok: true, source, output });
+			} catch (e) {
+				return json({ ok: false, source, output: e instanceof Error ? e.message : String(e) });
+			}
+		}
+
+		if (path === "/updates" && req.method === "GET") {
+			const snap = await loadUpdates(deps.stateDir);
+			return json(snap ?? { updates: [] });
+		}
+
+		if (path === "/catalog" && req.method === "GET") {
+			const snap = await loadCatalog(deps.stateDir);
+			return json(snap ?? { packages: [] });
+		}
+
+		return err(404, "not found");
+	}
+
+	return {
+		async fetch(req: Request): Promise<Response> {
+			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"].includes(new URL(req.url).pathname)) {
+				const hit = cache.get(req.url);
+				if (hit) {
+					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());
+				return res;
+			}
+			return route(req);
+		},
+	};
+}

package/src/state.ts

@@ -0,0 +1,48 @@
+/** 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 { randomBytes } from "node:crypto";
+
+export function stateDir(): string {
+	if (process.env["PI_PACKED_HOME"]) return process.env["PI_PACKED_HOME"];
+	try {
+		return join(homedir(), ".cache", "pi-packed");
+	} catch {
+		return join(tmpdir(), "pi-packed");
+	}
+}
+
+export function loadOrCreateToken(dir: string): string {
+	const path = join(dir, "token");
+	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"), 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/watcher.ts

@@ -0,0 +1,70 @@
+/**
+ * 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 type { InstalledPkg, Registry, UpdateEntry, UpdatesSnapshot } from "./ports.ts";
+
+function updatesPath(dir: string): string {
+	return join(dir, "updates.json");
+}
+
+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: drift = latest ≠ what we have (registry latest is authoritative). */
+export async function checkUpdates(reg: Registry, installed: InstalledPkg[]): Promise<UpdateEntry[]> {
+	const now = new Date().toISOString();
+	const updates: UpdateEntry[] = [];
+	for (const p of installed) {
+		const have = p.installed || p.pinned;
+		if (!have) continue;
+		try {
+			const info = await reg.info(p.name);
+			if (info.version && info.version !== have) {
+				updates.push({ name: p.name, installed: have, latest: info.version, detectedAt: now });
+			}
+		} catch (e) {
+			console.error(`updates: ${p.name}: ${e instanceof Error ? e.message : e}`);
+		}
+	}
+	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(
+	reg: Registry,
+	stateDir: string,
+	readInstalled: () => InstalledPkg[],
+	opts: WatcherOptions,
+): () => void {
+	async function check(): Promise<void> {
+		try {
+			const updates = await checkUpdates(reg, readInstalled());
+			await saveUpdates(stateDir, { checkedAt: new Date().toISOString(), updates });
+			if (updates.length > 0) console.error(`[packed] updates available: ${updates.length}`);
+		} catch (e) {
+			opts.onError?.(e);
+		}
+	}
+	void check();
+	const timer = setInterval(() => void check(), opts.intervalMs);
+	return () => clearInterval(timer);
+}