@valni/cli-darwin-x64 0.0.0-stage → 0.1.2

package/runtime/extensions/switchboard-local/extensions/local/engines/support.ts

@@ -0,0 +1,151 @@
+import { spawn, spawnSync } from "node:child_process";
+import { cpSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import type { ChildProcess } from "node:child_process";
+
+export function run(
+	command: string,
+	args: readonly string[],
+	options: { cwd?: string; env?: NodeJS.ProcessEnv; signal?: AbortSignal } = {},
+): Promise<void> {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, [...args], {
+			cwd: options.cwd,
+			env: options.env,
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+		let stderr = "";
+		child.stderr?.on("data", (chunk: Buffer) => {
+			stderr = `${stderr}${chunk.toString()}`.slice(-4000);
+		});
+		const abort = () => child.kill("SIGTERM");
+		options.signal?.addEventListener("abort", abort, { once: true });
+		child.once("error", (error) => {
+			options.signal?.removeEventListener("abort", abort);
+			reject(error);
+		});
+		child.once("close", (code) => {
+			options.signal?.removeEventListener("abort", abort);
+			if (code === 0) return resolve();
+			const tail = stderr.trim().split("\n").slice(-4).join("\n");
+			reject(new Error(`${command} exited with code ${code}${tail ? `\n${tail}` : ""}`));
+		});
+	});
+}
+
+export function directorySize(path: string): number {
+	let total = 0;
+	let entries: string[];
+	try {
+		entries = readdirSync(path);
+	} catch {
+		return 0;
+	}
+	for (const entry of entries) {
+		const child = join(path, entry);
+		try {
+			const stats = statSync(child);
+			total += stats.isDirectory() ? directorySize(child) : stats.size;
+		} catch {
+			continue;
+		}
+	}
+	return total;
+}
+
+export function findFile(root: string, name: string): string | undefined {
+	let entries: string[];
+	try {
+		entries = readdirSync(root);
+	} catch {
+		return undefined;
+	}
+	for (const entry of entries) {
+		const path = join(root, entry);
+		let stats;
+		try {
+			stats = statSync(path);
+		} catch {
+			continue;
+		}
+		if (stats.isDirectory()) {
+			const found = findFile(path, name);
+			if (found !== undefined) return found;
+		} else if (entry === name) {
+			return path;
+		}
+	}
+	return undefined;
+}
+
+export async function healthy(url: string, timeoutMs = 1_000): Promise<boolean> {
+	try {
+		const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+		return response.ok;
+	} catch {
+		return false;
+	}
+}
+
+export function detachChild(child: ChildProcess): void {
+	for (const pipe of [child.stderr, child.stdout]) {
+		(pipe as { unref?: () => void } | null)?.unref?.();
+	}
+	child.unref();
+}
+
+export function copyDir(from: string, to: string): void {
+	cpSync(from, to, { recursive: true });
+}
+
+export function killPid(pid: number, signal: NodeJS.Signals): void {
+	if (process.platform === "win32") {
+		try {
+			spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore" });
+		} catch {
+			return;
+		}
+		return;
+	}
+	try {
+		process.kill(-pid, signal);
+	} catch {
+		try {
+			process.kill(pid, signal);
+		} catch {
+			return;
+		}
+	}
+}
+
+export function killOnExit(release: () => number | undefined): void {
+	process.on("exit", () => {
+		const pid = release();
+		if (pid === undefined) return;
+		killPid(pid, "SIGKILL");
+	});
+}
+
+export function watchSpawn(child: ChildProcess): { failure: () => Error | undefined } {
+	let failure: Error | undefined;
+	child.on("error", (error: Error) => {
+		failure = error;
+	});
+	return { failure: () => failure };
+}
+
+export async function stopChild(child: ChildProcess, graceMs: number): Promise<void> {
+	if (child.exitCode !== null || child.pid === undefined) return;
+	const pid = child.pid;
+	killPid(pid, "SIGTERM");
+	await new Promise((resolve) => {
+		const timer = setTimeout(() => {
+			killPid(pid, "SIGKILL");
+			resolve(undefined);
+		}, graceMs);
+		child.once("exit", () => {
+			clearTimeout(timer);
+			resolve(undefined);
+		});
+	});
+}

package/runtime/extensions/switchboard-local/extensions/local/hf.ts

@@ -0,0 +1,106 @@
+const HOSTS = ["huggingface.co", "hf.co"];
+
+export function parseRepoId(input: string): string | null {
+	let text = input.trim();
+	for (const prefix of ["https://", "http://"]) {
+		if (text.toLowerCase().startsWith(prefix)) text = text.slice(prefix.length);
+	}
+	for (const host of HOSTS) {
+		if (text.toLowerCase().startsWith(`${host}/`)) text = text.slice(host.length + 1);
+	}
+	const cut = text.search(/[?#]/u);
+	if (cut !== -1) text = text.slice(0, cut);
+	text = text.replace(/^\/+|\/+$/gu, "");
+	if (text.includes(" ")) return null;
+	const parts = text.split("/");
+	if (parts.length !== 2) return null;
+	if (!parts[0] || !parts[1]) return null;
+	return text;
+}
+
+export interface ModelRef {
+	repoId: string;
+	quant?: string;
+}
+
+export function parseModelRef(input: string): ModelRef | null {
+	const trimmed = input.trim().replace(/\/+$/u, "");
+	const colon = trimmed.lastIndexOf(":");
+	const slash = trimmed.lastIndexOf("/");
+	if (colon > slash && colon !== -1) {
+		const repoId = parseRepoId(trimmed.slice(0, colon));
+		let quant = trimmed.slice(colon + 1).trim();
+		const cut = quant.search(/[?#]/u);
+		if (cut !== -1) quant = quant.slice(0, cut);
+		quant = quant.replace(/\/+$/u, "").trim();
+		if (repoId === null || !quant) return null;
+		return { repoId, quant: quant.toUpperCase() };
+	}
+	const repoId = parseRepoId(trimmed);
+	return repoId === null ? null : { repoId };
+}
+
+export interface RepoFile {
+	path: string;
+	size: number;
+}
+
+export async function repoFiles(repoId: string, signal?: AbortSignal): Promise<RepoFile[]> {
+	const encoded = repoId.split("/").map(encodeURIComponent).join("/");
+	const url = `https://huggingface.co/api/models/${encoded}/tree/main?recursive=1`;
+	const timeout = AbortSignal.timeout(20_000);
+	const response = await fetch(url, { signal: signal ? AbortSignal.any([signal, timeout]) : timeout });
+	if (!response.ok) {
+		if (response.status === 401 || response.status === 404) {
+			throw new Error(`${repoId} was not found on Hugging Face, or it is gated`);
+		}
+		throw new Error(`Hugging Face returned HTTP ${response.status} for ${repoId}`);
+	}
+	const payload: unknown = await response.json();
+	if (!Array.isArray(payload)) throw new Error("Hugging Face returned an unexpected tree listing");
+	return payload.flatMap((value) => {
+		if (typeof value !== "object" || value === null) return [];
+		const entry = value as { path?: unknown; size?: unknown; type?: unknown };
+		if (entry.type !== "file" || typeof entry.path !== "string") return [];
+		return [{ path: entry.path, size: typeof entry.size === "number" ? entry.size : 0 }];
+	});
+}
+
+export function totalBytes(files: readonly RepoFile[]): number {
+	return files.reduce((sum, file) => sum + file.size, 0);
+}
+
+export function looksLikeMlxRepo(files: readonly RepoFile[]): boolean {
+	const names = new Set(files.map((file) => file.path));
+	return names.has("config.json") && [...names].some((name) => name.endsWith(".safetensors"));
+}
+
+const QUANT_PATTERN =
+	/(?:^|[-_.])((?:UD-)?(?:IQ\d(?:_[A-Z0-9]+)+|Q\d(?:_[A-Z0-9]+)+|BF16|F16|F32|MXFP\d(?:_[A-Z0-9]+)*))$/iu;
+const SHARD_PATTERN = /-\d{5}-of-\d{5}$/u;
+const PREFERRED_QUANT = "Q4_K_M";
+
+export interface Quantization {
+	name: string;
+	size: number;
+}
+
+export function ggufQuants(files: readonly RepoFile[]): Quantization[] {
+	const sizes = new Map<string, number>();
+	for (const file of files) {
+		const name = file.path.split("/").at(-1) ?? "";
+		if (!name.toLowerCase().endsWith(".gguf")) continue;
+		if (name.toLowerCase().startsWith("mmproj")) continue;
+		const stem = name.slice(0, -5).replace(SHARD_PATTERN, "");
+		const quant = stem.match(QUANT_PATTERN)?.[1]?.toUpperCase();
+		if (!quant) continue;
+		sizes.set(quant, (sizes.get(quant) ?? 0) + file.size);
+	}
+	return [...sizes]
+		.map(([name, size]) => ({ name, size }))
+		.sort((left, right) => {
+			if (left.name === PREFERRED_QUANT) return -1;
+			if (right.name === PREFERRED_QUANT) return 1;
+			return left.size - right.size || left.name.localeCompare(right.name);
+		});
+}

package/runtime/extensions/switchboard-local/extensions/local/index.ts

@@ -0,0 +1,67 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { streamLocalModel } from "./nativeStream.ts";
+import type { LocalEngine } from "./engine.ts";
+import { GgufEngine } from "./engines/gguf.ts";
+import { MlxEngine } from "./engines/mlx.ts";
+import { PROVIDER_ID, PROVIDER_NAME, toModelConfigs } from "./provider.ts";
+import { addModel, showMenu } from "./ui.ts";
+
+const COMMAND = "switchboard-local";
+
+function extensionVersion(): string {
+	try {
+		const packagePath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+		return (JSON.parse(readFileSync(packagePath, "utf8")) as { version: string }).version;
+	} catch {
+		return "unknown";
+	}
+}
+
+async function readyModels(engines: readonly LocalEngine[]): Promise<ReturnType<typeof toModelConfigs>> {
+	const listed = await Promise.all(
+		engines.map(async (engine) => {
+			if (!engine.supported() || !engine.isInstalled()) return [];
+			try {
+				if (!engine.isRunning()) await engine.ensureReady(() => undefined);
+				return await engine.listModels();
+			} catch (error) {
+				console.error(`switchboard-local: the ${engine.label} engine could not list models`, error);
+				return [];
+			}
+		}),
+	);
+	return toModelConfigs(listed.flat());
+}
+
+export default async function (pi: ExtensionAPI) {
+	console.error(`switchboard-local v${extensionVersion()}`);
+	const engines: LocalEngine[] = [new MlxEngine(), new GgufEngine()];
+
+	pi.registerCommand(COMMAND, {
+		description: "Download and manage local models",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			if (args.trim()) {
+				await addModel(engines, ctx, args);
+				return;
+			}
+			await showMenu(engines, ctx);
+		},
+	});
+
+	pi.on("session_shutdown", async () => {
+		await Promise.all(engines.map((engine) => engine.stop()));
+	});
+
+	pi.registerProvider(PROVIDER_ID, {
+		name: PROVIDER_NAME,
+		baseUrl: "http://127.0.0.1/v1",
+		api: "openai-completions",
+		apiKey: "local",
+		streamSimple: streamLocalModel,
+		models: [],
+		refreshModels: async () => await readyModels(engines),
+	});
+}