@danypops/pi-packed 0.19.7 → 0.19.10

package/service/src/packages/install.ts

@@ -0,0 +1,60 @@
+/** install.ts — driven adapter: pi CLI mutations via Bun.spawn. */
+
+import { HeadlessInstallValidator, type InstallValidator } from "../adoption/install-validation.ts";
+import { defaultPiHome, isPinnedNpmSource, readResolvedVersion } from "./installed.ts";
+import type { Installer, UpdateOutcome } from "./package.ts";
+
+/** Bare npm package name (for `packed remove`). */
+export const NAME_RE = /^(@[A-Za-z0-9._-]+\/)?[A-Za-z0-9._-]+$/;
+
+export function defaultPiBin(): string {
+	return process.env.PI_PACKED_PI_BIN ?? process.env.PI_BIN ?? "pi";
+}
+
+export class ExecInstaller implements Installer {
+	constructor(
+		private bin = defaultPiBin(),
+		private piHome = defaultPiHome(),
+		private validator: InstallValidator = new HeadlessInstallValidator(),
+	) {}
+
+	private async run(args: string[]): Promise<string> {
+		const proc = Bun.spawn([this.bin, ...args], { stdout: "pipe", stderr: "pipe" });
+		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(out || `exit ${code}`);
+		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"}`);
+		}
+		return this.run(["install", ...(options?.local ? ["-l"] : []), source]);
+	}
+
+	remove(source: string, options?: { approved?: boolean; local?: boolean }): Promise<string> {
+		return this.run(["remove", ...(options?.local ? ["-l"] : []), source]);
+	}
+
+	async update(source: string, _options?: { approved?: boolean; local?: boolean }): Promise<UpdateOutcome> {
+		const pinned = isPinnedNpmSource(source);
+		const previousVersion = readResolvedVersion(this.piHome, source);
+		const output = await this.run(["update", "--extension", source]);
+		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
+		// node_modules). Otherwise (git:/https: sources, or an unreadable
+		// node_modules entry) fall back to the traditional "assume it may
+		// have changed" signal instead of falsely claiming it didn't.
+		const knowsBoth = previousVersion !== undefined && currentVersion !== undefined;
+		const changed = !knowsBoth || previousVersion !== currentVersion;
+		return { output, reloadRequired: changed, alreadyUpToDate: !changed, pinned, previousVersion, currentVersion };
+	}
+}

package/service/src/packages/installed.ts

@@ -0,0 +1,123 @@
+/** installed.ts — pi's settings.json is the source of truth for what is
+ * installed; node_modules supplies versions for unpinned sources. */
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { ENV, SETTINGS_FILE } from "../shared/constants.ts";
+import type { InstalledPkg } from "./package.ts";
+
+export function splitNpmSource(spec: string): [name: string, version: string] {
+	const i = spec.lastIndexOf("@");
+	if (i <= 0) return [spec, ""];
+	return [spec.slice(0, i), spec.slice(i + 1)];
+}
+
+function extractSource(entry: unknown): string {
+	if (typeof entry === "string") return entry;
+	if (entry && typeof entry === "object") {
+		const s = (entry as Record<string, unknown>).source;
+		if (typeof s === "string") return s;
+	}
+	return "";
+}
+
+function nodeModulesVersion(piHome: string, name: string): string | undefined {
+	try {
+		const pkg = JSON.parse(readFileSync(join(piHome, "npm", "node_modules", name, "package.json"), "utf8"));
+		return typeof pkg.version === "string" ? pkg.version : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * True when a configured npm: source pins an exact version, e.g.
+ * "npm:@scope/pkg@1.2.3" vs. the floating "npm:@scope/pkg". `pi update`
+ * intentionally leaves pinned sources unchanged (see readInstalledPackages)
+ * but still exits 0 and prints "Updated <source>" either way -- callers
+ * must not treat that text as proof anything changed.
+ */
+export function isPinnedNpmSource(source: string): boolean {
+	if (!source.startsWith("npm:")) return false;
+	const [, pinned] = splitNpmSource(source.slice(4));
+	return pinned !== "";
+}
+
+/** The bare npm package name for a configured npm: source, pinned or not.
+ * undefined for git:/https: sources -- there is no npm-registry name to read. */
+export function npmPackageName(source: string): string | undefined {
+	if (!source.startsWith("npm:")) return undefined;
+	const [name] = splitNpmSource(source.slice(4));
+	return name;
+}
+
+/** Reads a single npm package's real on-disk resolved version, regardless of
+ * whether its configured source is pinned -- ground truth for detecting
+ * whether an update actually changed anything. undefined for non-npm
+ * sources or when node_modules has no matching package.json to read. */
+export function readResolvedVersion(piHome: string, source: string): string | undefined {
+	const name = npmPackageName(source);
+	return name ? nodeModulesVersion(piHome, name) : undefined;
+}
+
+export function readResolvedIntegrity(piHome: string, source: string): string | undefined {
+	const name = npmPackageName(source);
+	if (!name) return undefined;
+	try {
+		const lock = JSON.parse(readFileSync(join(piHome, "npm", "package-lock.json"), "utf8")) as {
+			packages?: Record<string, { integrity?: unknown }>;
+		};
+		const integrity = lock.packages?.[`node_modules/${name}`]?.integrity;
+		return typeof integrity === "string" ? integrity : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export function readPackageDeclarations(piHome: string): string[] {
+	let settings: { packages?: unknown[] };
+	try {
+		settings = JSON.parse(readFileSync(join(piHome, SETTINGS_FILE), "utf8"));
+	} catch {
+		return [];
+	}
+	return (settings.packages ?? [])
+		.map(extractSource)
+		.filter((source) => source.length > 0)
+		.slice(0, 500);
+}
+
+export function readInstalledPackages(piHome: string): InstalledPkg[] {
+	const out: InstalledPkg[] = [];
+	for (const source of readPackageDeclarations(piHome)) {
+		if (!source.startsWith("npm:")) continue;
+		const [name, pinned] = splitNpmSource(source.slice(4));
+		out.push({
+			name,
+			pinned: pinned || undefined,
+			installed: pinned ? undefined : nodeModulesVersion(piHome, name),
+		});
+	}
+	return out;
+}
+
+/**
+ * Global scope alone is invisible to a project's own .pi/settings.json pin --
+ * confirmed live: a project pinned a stale major version of a since-split
+ * package, and nothing in packed's own drift detection ever saw it. Merges
+ * global and (when given) project-scoped declarations, tagging each so a
+ * name pinned differently in each scope is reported twice, not silently
+ * deduped into one.
+ */
+export function readInstalledPackagesAcrossScopes(piHome: string, projectRoot?: string): InstalledPkg[] {
+	const global = readInstalledPackages(piHome).map((pkg) => ({ ...pkg, scope: "global" as const }));
+	if (!projectRoot) return global;
+	const project = readInstalledPackages(join(projectRoot, ".pi")).map((pkg) => ({ ...pkg, scope: "project" as const }));
+	return [...global, ...project];
+}
+
+export function defaultPiHome(): string {
+	const envHome = process.env[ENV.PI_HOME];
+	if (envHome) return envHome;
+	return join(homedir(), ".pi", "agent");
+}

package/service/src/packages/package.ts

@@ -0,0 +1,141 @@
+/**
+ * package.ts — the Pkg entity and its two driven ports (Registry, Installer)
+ * that decouple callers (the HTTP service, the CLI, the watcher, tests) from
+ * concrete implementations (registry/registry.ts talks to npm; install.ts
+ * shells out to pi).
+ */
+
+export type PackageVerification = "keyword-only" | "manifest" | "conventional";
+
+export interface PackageEvidence {
+	shape: PackageVerification;
+	verified: boolean;
+	evidence: string[];
+}
+
+export interface PublicationEvidence {
+	integrity?: string;
+	provenanceUrl?: string;
+	trustedPublisher: "verified" | "not-verified" | "unknown";
+}
+
+export interface DownloadObservations {
+	weekly?: number;
+	monthly?: number;
+	observedAt: string;
+}
+
+export interface Pkg {
+	name: string;
+	version: string;
+	description?: string;
+	date?: string;
+	packageEvidence?: PackageEvidence;
+	publication?: PublicationEvidence;
+}
+
+export interface PkgInfo {
+	name: string;
+	version: string;
+	description?: string;
+	homepage?: string;
+	repository?: string;
+	/** Monorepo subdirectory the package lives in, from repository.directory
+	 * -- scopes a real commit-history lookup to the package's own path. */
+	repositoryDirectory?: string;
+	license?: string;
+	keywords?: string[];
+	pi?: Record<string, unknown>;
+	/** Declared npm lifecycle scripts (preinstall/install/postinstall/etc.) --
+	 * these execute on install, a top supply-chain attack vector. Presence is
+	 * surfaced as trust-dimension evidence, never treated as a failure. */
+	scripts?: Record<string, string>;
+	modified?: string;
+	unpackedSize?: number;
+	readme?: string;
+	readmeAvailable?: boolean;
+	bugs?: string;
+	peerDependencies?: Record<string, string>;
+	packageEvidence?: PackageEvidence;
+	publication?: PublicationEvidence;
+	downloads?: DownloadObservations;
+}
+
+export interface SearchPage {
+	results: Pkg[];
+	total: number;
+}
+
+/** Driven port: package metadata source (npm registry, or the daemon proxy). */
+export interface Registry {
+	search(query: string, limit: number): Promise<SearchPage>;
+	searchPage(query: string, from: number, size: number): Promise<SearchPage>;
+	searchAll(query: string): Promise<Pkg[]>;
+	info(name: string): Promise<PkgInfo>;
+	downloads?(name: string): Promise<DownloadObservations>;
+	/** Last npm publish date across any version, from the abbreviated
+	 * multi-version doc -- the `/latest` endpoint `info()` uses carries no
+	 * `time`/`modified` field at all. Optional, like `downloads`; undefined
+	 * on any failure, never thrown. */
+	modifiedAt?(name: string): Promise<string | undefined>;
+}
+
+/**
+ * `pi update --extension <source>` exits 0 and prints "Updated <source>"
+ * whether or not anything actually changed -- verified empirically against
+ * both a pinned, already-current source and an unpinned, already-latest
+ * one. reloadRequired/alreadyUpToDate are ground truth (on-disk resolved
+ * version, before vs. after), not that text. previousVersion/currentVersion
+ * are omitted when unknown (git:/https: sources, or no node_modules entry
+ * to read) -- reloadRequired then conservatively stays true rather than
+ * guessing.
+ */
+export interface UpdateOutcome {
+	output: string;
+	reloadRequired: boolean;
+	alreadyUpToDate: boolean;
+	pinned: boolean;
+	previousVersion?: string;
+	currentVersion?: string;
+}
+
+/** Driven port: pi CLI mutations. */
+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>;
+}
+
+export interface InstalledPkg {
+	name: string;
+	pinned?: string;
+	installed?: string;
+	scope?: "global" | "project";
+}
+
+export interface UpdateEntry {
+	name: string;
+	installed: string;
+	latest: string;
+	detectedAt?: string;
+	scope?: "global" | "project";
+}
+
+export interface UpdatesSnapshot {
+	checkedAt: string;
+	updates: UpdateEntry[];
+}
+
+/** Scope every query to pi packages unless the caller already qualified it. */
+import { PI_PACKAGE_KEYWORD } from "../shared/constants.ts";
+
+export function buildSearchQuery(q: string): string {
+	const t = q.trim();
+	if (t.includes("keywords:")) return t;
+	return t === "" ? PI_PACKAGE_KEYWORD : `${PI_PACKAGE_KEYWORD} ${t}`;
+}
+
+export function clampLimit(v: number, def: number, max: number): number {
+	if (!Number.isFinite(v) || v <= 0) return def;
+	return Math.min(v, max);
+}

package/service/src/packages/resources.ts

@@ -0,0 +1,203 @@
+/**
+ * resources.ts — enable/disable individual extensions, skills, prompt
+ * templates, and themes declared by installed Pi packages, through the
+ * same documented settings.json packages[].{extensions,skills,prompts,
+ * themes} filter arrays pi config itself writes (docs/packages.md,
+ * "Enable and Disable Resources"). Packed owns this mutation the same way
+ * it owns every other settings.json change -- atomically, through the
+ * daemon -- without importing any of pi's own internal SettingsManager.
+ *
+ * Scope: npm: sources only for now. git:/local package resource discovery
+ * needs a different on-disk resolution strategy and is a documented
+ * follow-up; those entries are simply omitted from the list rather than
+ * reported inaccurately.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { discoverPackageResources, matchesPattern, type ResourceField, walk } from "../adoption/check.ts";
+import { writeJsonAtomic } from "../shared/atomic-json.ts";
+
+export type { ResourceField };
+
+export const RESOURCE_FIELDS = ["extensions", "skills", "prompts", "themes"] as const satisfies readonly ResourceField[];
+
+const MAX_PACKAGE_ENTRIES = 500;
+const MAX_RESOURCE_FILES = 1_000;
+
+export interface ResourceItem {
+	path: string;
+	enabled: boolean;
+}
+
+export type PackageResources = { source: string; name: string; scope: "global" | "project" } & Record<ResourceField, ResourceItem[]>;
+
+interface PackageEntry {
+	source: string;
+	extensions?: string[];
+	skills?: string[];
+	prompts?: string[];
+	themes?: string[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function parseEntry(raw: unknown): PackageEntry | undefined {
+	if (typeof raw === "string") return { source: raw };
+	if (!isRecord(raw) || typeof raw.source !== "string") return undefined;
+	const entry: PackageEntry = { source: raw.source };
+	for (const field of RESOURCE_FIELDS) {
+		const value = raw[field];
+		if (Array.isArray(value) && value.every((item) => typeof item === "string")) entry[field] = value as string[];
+	}
+	return entry;
+}
+
+function readSettingsPackages(settingsPath: string): PackageEntry[] {
+	try {
+		const settings = JSON.parse(readFileSync(settingsPath, "utf8")) as { packages?: unknown[] };
+		return (settings.packages ?? [])
+			.map(parseEntry)
+			.filter((entry): entry is PackageEntry => entry !== undefined)
+			.slice(0, MAX_PACKAGE_ENTRIES);
+	} catch {
+		return [];
+	}
+}
+
+/** The bare npm package name for an npm: source, pinned or not. */
+function npmName(source: string): string {
+	const spec = source.slice("npm:".length);
+	const at = spec.lastIndexOf("@");
+	return at > 0 ? spec.slice(0, at) : spec;
+}
+
+export function resolveInstalledDir(piHome: string, source: string): string | undefined {
+	if (!source.startsWith("npm:")) return undefined;
+	const dir = join(piHome, "npm", "node_modules", npmName(source));
+	return existsSync(dir) ? dir : undefined;
+}
+
+/** Layers a settings-level filter over a package's own discovered resource
+ * set, matching pi's own package-manager applyPatterns exactly (four
+ * ordered steps: bare patterns select from everything when none are given,
+ * then !excludes narrow, then +forceIncludes add back from the full base
+ * set overriding excludes, then -forceExcludes always win last). An
+ * omitted filter key loads everything; [] loads nothing. */
+function applyFilter(baseFiles: string[], filter: string[] | undefined): Set<string> {
+	if (filter === undefined) return new Set(baseFiles);
+	if (filter.length === 0) return new Set(); // an explicit [] disables every resource of this type
+	const includes: string[] = [];
+	const excludes: string[] = [];
+	const forceIncludes: string[] = [];
+	const forceExcludes: string[] = [];
+	for (const raw of filter) {
+		if (raw.startsWith("+")) forceIncludes.push(raw.slice(1));
+		else if (raw.startsWith("-")) forceExcludes.push(raw.slice(1));
+		else if (raw.startsWith("!")) excludes.push(raw.slice(1));
+		else includes.push(raw);
+	}
+	let result =
+		includes.length === 0 ? [...baseFiles] : baseFiles.filter((file) => includes.some((pattern) => matchesPattern(file, pattern)));
+	if (excludes.length > 0) result = result.filter((file) => !excludes.some((pattern) => matchesPattern(file, pattern)));
+	if (forceIncludes.length > 0) {
+		for (const file of baseFiles) {
+			if (!result.includes(file) && forceIncludes.includes(file)) result.push(file);
+		}
+	}
+	if (forceExcludes.length > 0) result = result.filter((file) => !forceExcludes.includes(file));
+	return new Set(result);
+}
+
+function resourcesForEntry(entry: PackageEntry, piHome: string, scope: "global" | "project"): PackageResources | undefined {
+	const dir = resolveInstalledDir(piHome, entry.source);
+	if (!dir) return undefined;
+	let pkg: Record<string, unknown>;
+	try {
+		pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+	} catch {
+		return undefined;
+	}
+	const { files } = walk(dir, MAX_RESOURCE_FILES, []);
+	const discovered = discoverPackageResources(dir, pkg, files);
+	const result = { source: entry.source, name: npmName(entry.source), scope } as PackageResources;
+	for (const field of RESOURCE_FIELDS) {
+		const enabled = applyFilter(discovered[field], entry[field]);
+		result[field] = discovered[field].map((path) => ({ path, enabled: enabled.has(path) })).sort((a, b) => a.path.localeCompare(b.path));
+	}
+	return result;
+}
+
+/** projectRoot, when given, resolves both .pi/settings.json (declarations)
+ * and .pi/ as the install home for project-local npm packages -- the same
+ * -l convention setup.ts already uses, so global and project packages of
+ * the same name never collide on one resolved directory. */
+export function listPackageResources(piHome: string, projectRoot?: string): { global: PackageResources[]; project: PackageResources[] } {
+	const global = readSettingsPackages(join(piHome, "settings.json"))
+		.map((entry) => resourcesForEntry(entry, piHome, "global"))
+		.filter((item): item is PackageResources => item !== undefined);
+	if (!projectRoot) return { global, project: [] };
+	const projectHome = join(projectRoot, ".pi");
+	const project = readSettingsPackages(join(projectHome, "settings.json"))
+		.map((entry) => resourcesForEntry(entry, projectHome, "project"))
+		.filter((item): item is PackageResources => item !== undefined);
+	return { global, project };
+}
+
+/** The exact settings.json a toggle targets -- shared by the daemon's
+ * resources.toggle route and the standalone CLI fallback so they can never
+ * drift onto two different resolutions of the same package's settings. */
+export function resolveToggleSettingsPath(piHome: string, projectRoot?: string): string {
+	return projectRoot ? join(projectRoot, ".pi", "settings.json") : join(piHome, "settings.json");
+}
+
+async function atomicWriteJson(path: string, value: unknown): Promise<void> {
+	await writeJsonAtomic(path, value, { mode: 0o644, pretty: true });
+}
+
+export interface ToggleResourceInput {
+	settingsPath: string;
+	source: string;
+	field: ResourceField;
+	path: string;
+	enabled: boolean;
+}
+
+/** Toggles one resource's enabled state by rewriting its package entry's
+ * filter array with a minimal +path/-path override -- never touches the
+ * package's own glob-based defaults, and is idempotent for the same path.
+ * Matches pi's own pi config strip-and-append strategy exactly, including
+ * its one known edge case: re-enabling a single resource out of an
+ * explicit [] (disable-all-of-this-type) state re-enables the whole type,
+ * because the array stops being empty and the general apply-patterns
+ * algorithm treats "no bare include pattern" as "include everything" once
+ * it is no longer literally []. This is upstream's real behavior, not a
+ * Packed-specific bug -- parity with pi's own semantics matters more than
+ * a locally "nicer" model the actual loader wouldn't agree with. */
+export async function toggleResource(input: ToggleResourceInput): Promise<{ ok: boolean; error?: string }> {
+	let settings: Record<string, unknown>;
+	try {
+		settings = JSON.parse(readFileSync(input.settingsPath, "utf8"));
+	} catch (error) {
+		return { ok: false, error: error instanceof Error ? error.message : String(error) };
+	}
+	const packages = Array.isArray(settings.packages) ? [...settings.packages] : [];
+	const index = packages.findIndex((raw) => parseEntry(raw)?.source === input.source);
+	if (index === -1) return { ok: false, error: `package not found in settings: ${input.source}` };
+	const existing = parseEntry(packages[index]);
+	if (!existing) return { ok: false, error: `invalid package entry: ${input.source}` };
+	const current = existing[input.field] ?? [];
+	const withoutOverride = current.filter((entry) => entry !== `+${input.path}` && entry !== `-${input.path}`);
+	const updated = [...withoutOverride, `${input.enabled ? "+" : "-"}${input.path}`];
+	const merged: Record<string, unknown> =
+		typeof packages[index] === "string" ? { source: packages[index] } : { ...(packages[index] as Record<string, unknown>) };
+	merged[input.field] = updated;
+	packages[index] = merged;
+	try {
+		await atomicWriteJson(input.settingsPath, { ...settings, packages });
+	} catch (error) {
+		return { ok: false, error: error instanceof Error ? error.message : String(error) };
+	}
+	return { ok: true };
+}