bfi-cli 0.1.89 → 0.1.91

package/dist/_chunks/registry-client.mjs

@@ -0,0 +1,535 @@
+import { createHash, randomUUID } from "node:crypto";
+import { closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import https from "node:https";
+import http from "node:http";
+import { mkdir, writeFile } from "node:fs/promises";
+import { gunzipSync } from "node:zlib";
+import yauzl from "yauzl";
+import tar from "tar-stream";
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+const digestPattern = /^[a-f0-9]{64}$/u;
+const targets = /* @__PURE__ */ new Set([
+	"claude-code",
+	"codex",
+	"zcode",
+	"codebuddy",
+	"qwen-code"
+]);
+function normalizeRegistry(registry) {
+	const url = new URL(registry);
+	if (!["https:", "http:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) throw new Error("Registry must be an HTTP(S) base URL without credentials, query or fragment");
+	return url.toString().replace(/\/+$/u, "");
+}
+function canonicalIdentity(identity) {
+	if (!identity || !identity.version || !targets.has(identity.agent)) throw new Error("Invalid plugin identity");
+	if (identity.scope !== "user" && identity.scope !== "project") throw new Error("Invalid plugin scope");
+	if (identity.scope === "project" && (!identity.projectPath || !isAbsolute(identity.projectPath))) throw new Error("Project scope requires a canonical absolute project path");
+	if (identity.scope === "user" && identity.projectPath !== null) throw new Error("User scope cannot contain a project path");
+	const source = identity.source;
+	let sourceKey;
+	if (source.kind === "registry") {
+		if (!/^[1-9][0-9]*$/u.test(source.packageId) || !/^@[^/\s]+\/[^/\s]+$/u.test(source.packageRef)) throw new Error("Registry source needs an exact package ID and namespace-qualified reference");
+		sourceKey = [
+			"registry",
+			normalizeRegistry(source.registry),
+			source.packageId,
+			source.packageRef
+		];
+	} else if (source.kind === "local") {
+		if (!isAbsolute(source.sourcePath) || !digestPattern.test(source.sourceDigest)) throw new Error("Local source needs an absolute path and content digest");
+		sourceKey = [
+			"local",
+			resolve(source.sourcePath),
+			source.sourceDigest
+		];
+	} else throw new Error("Unknown plugin source");
+	return [
+		sourceKey,
+		identity.agent,
+		identity.scope,
+		identity.projectPath ? resolve(identity.projectPath) : null
+	];
+}
+function pluginSlotKey(identity) {
+	return hash(JSON.stringify(canonicalIdentity(identity)));
+}
+function pluginInstallKey(identity) {
+	return hash(JSON.stringify([...canonicalIdentity(identity), identity.version]));
+}
+var PluginInstallRecords = class {
+	root;
+	directory;
+	file;
+	constructor(root) {
+		this.root = realpathSync(root);
+		this.directory = join(this.root, ".bfi");
+		this.file = join(this.directory, "plugin-lock.json");
+	}
+	checkPaths() {
+		for (const candidate of [this.directory, this.file]) {
+			let info;
+			try {
+				info = lstatSync(candidate);
+			} catch (error) {
+				if (error.code === "ENOENT") continue;
+				throw error;
+			}
+			if (info.isSymbolicLink() || (candidate === this.directory ? !info.isDirectory() : !info.isFile())) throw new Error("Plugin store must not follow links or special files");
+		}
+	}
+	read() {
+		this.checkPaths();
+		if (!existsSync(this.file)) return {
+			version: 1,
+			active: {},
+			operations: {}
+		};
+		const value = JSON.parse(readFileSync(this.file, "utf8"));
+		if (value?.version !== 1 || !value.active || !value.operations || typeof value.active !== "object" || typeof value.operations !== "object" || Array.isArray(value.active) || Array.isArray(value.operations)) throw new Error("Invalid plugin lock; refusing to overwrite it");
+		for (const record of Object.values(value.operations)) {
+			pluginInstallKey(record.identity);
+			if (!digestPattern.test(record.artifactSha256) || !digestPattern.test(record.treeDigest) || !isAbsolute(record.artifactDirectory) || !["INSTALL", "UNINSTALL"].includes(record.action) || ![
+				"PREPARED",
+				"COMPLETED",
+				"FAILED",
+				"REMOVED"
+			].includes(record.state)) throw new Error("Invalid plugin record");
+		}
+		for (const [slot, operationId] of Object.entries(value.active)) {
+			const record = value.operations[operationId];
+			if (!record || record.state !== "COMPLETED" || pluginSlotKey(record.identity) !== slot) throw new Error("Invalid active plugin record");
+		}
+		return value;
+	}
+	update(change) {
+		this.checkPaths();
+		mkdirSync(this.directory, {
+			recursive: true,
+			mode: 448
+		});
+		const guard = join(this.directory, "plugin-lock.guard");
+		try {
+			mkdirSync(guard, { mode: 448 });
+		} catch {
+			throw new Error("Plugin records are locked by another operation; inspect an interrupted operation before recovering its lock");
+		}
+		const temporary = join(this.directory, `plugin-lock.${randomUUID()}.tmp`);
+		try {
+			const lock = this.read();
+			const result = change(lock);
+			const descriptor = openSync(temporary, "wx", 384);
+			try {
+				writeFileSync(descriptor, JSON.stringify(lock, null, 2) + "\n");
+				fsyncSync(descriptor);
+			} finally {
+				closeSync(descriptor);
+			}
+			this.checkPaths();
+			renameSync(temporary, this.file);
+			const directoryDescriptor = openSync(this.directory, "r");
+			try {
+				fsyncSync(directoryDescriptor);
+			} finally {
+				closeSync(directoryDescriptor);
+			}
+			return result;
+		} finally {
+			if (existsSync(temporary)) unlinkSync(temporary);
+			rmdirSync(guard);
+		}
+	}
+	prepare(identity, artifactSha256, adapterVersion, artifact) {
+		pluginInstallKey(identity);
+		if (identity.scope === "project" && realpathSync(identity.projectPath) !== this.root) throw new Error("Plugin record belongs to a different project");
+		if (!digestPattern.test(artifactSha256) || !adapterVersion || !digestPattern.test(artifact.treeDigest) || !isAbsolute(artifact.artifactDirectory)) throw new Error("Verified artifact and adapter identity required");
+		return this.update((lock) => {
+			const slot = pluginSlotKey(identity);
+			if (Object.values(lock.operations).some((record) => record.state === "PREPARED" && pluginSlotKey(record.identity) === slot)) throw new Error("A prepared operation already owns this plugin slot; verify or recover it first");
+			const identifier = randomUUID();
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			lock.operations[identifier] = {
+				identity: structuredClone(identity),
+				artifactSha256,
+				adapterVersion,
+				...artifact,
+				action: "INSTALL",
+				state: "PREPARED",
+				createdAt: now,
+				updatedAt: now
+			};
+			return identifier;
+		});
+	}
+	complete(operationId, receipt) {
+		if (!receipt.verified || !receipt.installationId) throw new Error("Native host verification is required");
+		this.update((lock) => {
+			const record = lock.operations[operationId];
+			if (!record || record.state !== "PREPARED" || record.action !== "INSTALL") throw new Error("Install operation is not prepared");
+			record.state = "COMPLETED";
+			record.installationId = receipt.installationId;
+			record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+			lock.active[pluginSlotKey(record.identity)] = operationId;
+		});
+	}
+	fail(operationId, errorCode) {
+		if (!/^[A-Z_]{1,80}$/u.test(errorCode)) throw new Error("Store only a safe failure code, not host output");
+		this.update((lock) => {
+			const record = lock.operations[operationId];
+			if (!record || record.state !== "PREPARED") throw new Error("Operation is not prepared");
+			record.state = "FAILED";
+			record.errorCode = errorCode;
+			record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		});
+	}
+	prepareRemoval(operationId) {
+		return this.update((lock) => {
+			const record = lock.operations[operationId];
+			if (!record || record.state !== "COMPLETED" || lock.active[pluginSlotKey(record.identity)] !== operationId) throw new Error("Only the exact active installation can be removed");
+			const slot = pluginSlotKey(record.identity);
+			if (Object.values(lock.operations).some((item) => item.state === "PREPARED" && pluginSlotKey(item.identity) === slot)) throw new Error("A prepared operation already owns this plugin slot");
+			const identifier = randomUUID(), now = (/* @__PURE__ */ new Date()).toISOString();
+			lock.operations[identifier] = {
+				...structuredClone(record),
+				action: "UNINSTALL",
+				targetOperationId: operationId,
+				state: "PREPARED",
+				createdAt: now,
+				updatedAt: now
+			};
+			return identifier;
+		});
+	}
+	removed(removalId) {
+		this.update((lock) => {
+			const removal = lock.operations[removalId];
+			if (!removal || removal.action !== "UNINSTALL" || removal.state !== "PREPARED" || !removal.targetOperationId) throw new Error("Removal is not prepared");
+			const record = lock.operations[removal.targetOperationId];
+			if (!record || lock.active[pluginSlotKey(record.identity)] !== removal.targetOperationId) throw new Error("Only the exact active installation can be removed");
+			record.state = "REMOVED";
+			record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+			removal.state = "REMOVED";
+			removal.updatedAt = record.updatedAt;
+			delete lock.active[pluginSlotKey(record.identity)];
+		});
+	}
+};
+const pluginArchiveLimits = {
+	compressedBytes: 50 * 1024 ** 2,
+	expandedBytes: 200 * 1024 ** 2,
+	fileBytes: 20 * 1024 ** 2,
+	entries: 1e4,
+	pathBytes: 1024
+};
+const sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const utf8 = new TextDecoder("utf-8", { fatal: true });
+const manifestPaths = {
+	".claude-plugin/plugin.json": "CLAUDE",
+	".codex-plugin/plugin.json": "CODEX",
+	".zcode-plugin/plugin.json": "ZCODE",
+	".cursor-plugin/plugin.json": "CURSOR",
+	".codebuddy-plugin/plugin.json": "CODEBUDDY",
+	"qwen-extension.json": "QWEN"
+};
+function safeArchivePath(input, directory = false, maximum = pluginArchiveLimits.pathBytes) {
+	if (!input || input.startsWith("/") || input.includes("\\") || /[\u0000-\u001f\u007f-\u009f]/u.test(input)) throw new Error("Unsafe archive path");
+	const name = input.replace(/^(?:\.\/)+/u, "").replace(directory ? /\/$/u : /$^/u, "");
+	if (!name || Buffer.byteLength(name) > maximum || name.split("/").some((segment) => !segment || segment === "." || segment === ".." || segment.includes(":"))) throw new Error("Unsafe archive segment or path limit");
+	return name;
+}
+function checkCredentials(file) {
+	const lower = file.path.toLowerCase(), basename = lower.split("/").pop();
+	if (basename === ".env" || basename.startsWith(".env.") && ![
+		".env.example",
+		".env.sample",
+		".env.template"
+	].includes(basename) || [
+		"id_rsa",
+		"id_ed25519",
+		".credentials.json",
+		"credentials"
+	].includes(basename) || lower.startsWith(".git/") || lower.includes("/.git/")) throw new Error("Archive contains a credential or repository-private file");
+	const text = file.content.toString("utf8");
+	checkCredentialText(text);
+	if (lower.endsWith(".json")) {
+		let decoded;
+		try {
+			decoded = JSON.parse(text);
+		} catch {
+			return;
+		}
+		checkCredentialText(JSON.stringify(decoded));
+	}
+}
+function checkCredentialText(text) {
+	if (/AKIA[0-9A-Z]{16}|gh[pousr]_[A-Za-z0-9]{20,}|sk-[A-Za-z0-9_-]{20,}|-----BEGIN (?:[A-Z ]+ )?PRIVATE KEY-----/u.test(text)) throw new Error("Archive contains a credential literal");
+	for (const match of text.matchAll(/(?:api[_-]?key|access[_-]?key|secret(?:[_-]?key)?|password|token|authorization|x-pm-[as]k)["']?\s*[:=]\s*["']?(?:Bearer\s+)?([A-Za-z0-9_/-]{12,})/giu)) if (![
+		"YOUR_API_KEY",
+		"YOUR_ACCESS_TOKEN",
+		"YOUR_PASSWORD",
+		"REPLACE_ME",
+		"placeholder"
+	].includes(match[1])) throw new Error("Archive contains a possible credential literal");
+}
+function treeDigest(files) {
+	const digest = createHash("sha256");
+	for (const file of [...files].sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0)) {
+		const path = Buffer.from(file.path), length = Buffer.alloc(4), size = Buffer.alloc(8);
+		length.writeUInt32BE(path.length);
+		size.writeBigUInt64BE(BigInt(file.content.length));
+		digest.update(length).update(path).update(Buffer.from(sha256(file.content), "hex")).update(size).update(Buffer.from([file.executable ? 1 : 0]));
+	}
+	return digest.digest("hex");
+}
+function describe(files) {
+	files.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+	const manifests = [];
+	for (const file of files) {
+		if (file.path !== "plugin.json" && !file.path.endsWith("/plugin.json") && file.path !== "qwen-extension.json" && !file.path.endsWith("/qwen-extension.json")) continue;
+		const nativePath = Object.keys(manifestPaths).find((candidate) => file.path === candidate || file.path.endsWith("/" + candidate));
+		const manifest = {
+			path: file.path,
+			root: file.path.slice(0, -(nativePath ?? "plugin.json").length).replace(/\/$/u, ""),
+			format: nativePath ? manifestPaths[nativePath] : "UNKNOWN",
+			invalid: false
+		};
+		try {
+			if (file.content.length > 1024 ** 2) throw new Error();
+			const parsed = JSON.parse(utf8.decode(file.content));
+			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error();
+			if (manifest.format === "UNKNOWN" && parsed.$schema === "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json") manifest.format = "AGENT_PLUGINS_V1";
+			manifest.name = typeof parsed.name === "string" ? parsed.name : void 0;
+			manifest.version = typeof parsed.version === "string" ? parsed.version : void 0;
+		} catch {
+			manifest.invalid = true;
+		}
+		manifests.push(manifest);
+	}
+	return {
+		files,
+		treeDigest: treeDigest(files),
+		manifests,
+		roots: manifests.length ? [...new Set(manifests.map((item) => item.root))].sort() : [""]
+	};
+}
+async function limitedRead(stream, maximum) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of stream) {
+		if (!Buffer.isBuffer(chunk)) throw new Error("Invalid archive stream");
+		size += chunk.length;
+		if (size > maximum) throw new Error("Archive file limit exceeded");
+		chunks.push(chunk);
+	}
+	return Buffer.concat(chunks);
+}
+function crc32(bytes) {
+	let crc = 4294967295;
+	for (const byte of bytes) {
+		crc ^= byte;
+		for (let bit = 0; bit < 8; bit++) crc = crc >>> 1 ^ (crc & 1 ? 3988292384 : 0);
+	}
+	return (crc ^ 4294967295) >>> 0;
+}
+async function inspectPluginArchive(archive, filename, overrides = {}) {
+	const limits = {
+		...pluginArchiveLimits,
+		...overrides
+	};
+	if (Object.values(limits).some((value) => !Number.isSafeInteger(value) || value <= 0)) throw new Error("Invalid archive limits");
+	if (archive.length > limits.compressedBytes) throw new Error("Compressed archive limit exceeded");
+	const files = [], paths = /* @__PURE__ */ new Map();
+	let count = 0, expanded = 0;
+	const register = (raw, directory) => {
+		if (++count > limits.entries) throw new Error("Archive entry count exceeded");
+		const path = safeArchivePath(raw, directory, limits.pathBytes), key = path.normalize("NFC").toLowerCase();
+		if (paths.has(key)) throw new Error("Duplicate or case/unicode path collision");
+		for (const [known, knownDirectory] of paths) if (!knownDirectory && key.startsWith(known + "/") || !directory && known.startsWith(key + "/")) throw new Error("File/directory collision");
+		paths.set(key, directory);
+		return path;
+	};
+	const append = (file) => {
+		expanded += file.content.length;
+		if (expanded > limits.expandedBytes) throw new Error("Expanded archive limit exceeded");
+		checkCredentials(file);
+		files.push(file);
+	};
+	if (/\.zip$/iu.test(filename)) {
+		const zip = await new Promise((resolve, reject) => yauzl.fromBuffer(archive, {
+			lazyEntries: true,
+			decodeStrings: true,
+			strictFileNames: true,
+			validateEntrySizes: true
+		}, (error, result) => error ? reject(error) : resolve(result)));
+		try {
+			if (zip.entryCount > limits.entries) throw new Error("Archive entry count exceeded");
+			await new Promise((resolve, reject) => {
+				zip.on("error", reject).on("end", resolve).on("entry", (entry) => {
+					(async () => {
+						const raw = utf8.decode(entry.fileNameRaw), directory = entry.fileName.endsWith("/");
+						safeArchivePath(raw, directory, limits.pathBytes);
+						const path = register(entry.fileName, directory), mode = entry.externalFileAttributes >>> 16, kind = mode & 61440;
+						if (![
+							0,
+							32768,
+							16384
+						].includes(kind) || kind === 16384 && !directory || entry.isEncrypted() || ![0, 8].includes(entry.compressionMethod)) throw new Error("Unsupported or special ZIP entry");
+						if (!(await new Promise((resolveHeader, rejectHeader) => zip.readLocalFileHeader(entry, (error, value) => error ? rejectHeader(error) : resolveHeader(value)))).fileName.equals(entry.fileNameRaw)) throw new Error("Conflicting ZIP local path");
+						if (directory) {
+							if (entry.uncompressedSize) throw new Error("Nonempty ZIP directory");
+							zip.readEntry();
+							return;
+						}
+						if (entry.uncompressedSize > limits.fileBytes) throw new Error("Archive file limit exceeded");
+						const content = await limitedRead(await new Promise((resolveStream, rejectStream) => zip.openReadStream(entry, (error, value) => error ? rejectStream(error) : resolveStream(value))), Math.min(limits.fileBytes, limits.expandedBytes - expanded));
+						if (content.length !== entry.uncompressedSize || crc32(content) !== entry.crc32) throw new Error("ZIP size or checksum mismatch");
+						append({
+							path,
+							content,
+							executable: (mode & 73) !== 0
+						});
+						zip.readEntry();
+					})().catch(reject);
+				});
+				zip.readEntry();
+			});
+		} finally {
+			zip.close();
+		}
+	} else if (/\.(tgz|tar\.gz)$/iu.test(filename)) {
+		let bytes;
+		try {
+			bytes = gunzipSync(archive, { maxOutputLength: limits.expandedBytes });
+		} catch {
+			throw new Error("Invalid gzip or expanded archive limit exceeded");
+		}
+		const extractor = tar.extract();
+		await new Promise((resolve, reject) => {
+			extractor.on("error", reject).on("finish", resolve).on("entry", (header, stream, next) => {
+				(async () => {
+					const directory = header.type === "directory";
+					if (directory && [".", "./"].includes(header.name)) {
+						stream.resume();
+						next();
+						return;
+					}
+					if (!directory && header.type !== "file") throw new Error("Unsupported or special TAR entry");
+					if (header.pax && Object.keys(header.pax).some((key) => /sparse/iu.test(key))) throw new Error("Sparse TAR is unsupported");
+					const path = register(header.name, directory);
+					if ((header.size ?? 0) > limits.fileBytes) throw new Error("Archive file limit exceeded");
+					const content = await limitedRead(stream, limits.fileBytes);
+					if (content.length !== (header.size ?? 0) || directory && content.length) throw new Error("Invalid TAR size");
+					if (!directory) append({
+						path,
+						content,
+						executable: ((header.mode ?? 0) & 73) !== 0
+					});
+					next();
+				})().catch((error) => extractor.destroy(error));
+			});
+			extractor.end(bytes);
+		});
+	} else throw new Error("Expected zip or tgz plugin archive");
+	return describe(files);
+}
+function selectPluginRoot(tree, root) {
+	if (!tree.roots.includes(root)) throw new Error("Unknown plugin root");
+	return root ? describe(tree.files.filter((file) => file.path.startsWith(root + "/")).map((file) => ({
+		...file,
+		path: file.path.slice(root.length + 1)
+	}))) : tree;
+}
+async function materializePluginTree(tree, freshDirectory) {
+	if (tree.treeDigest !== treeDigest(tree.files)) throw new Error("Plugin tree changed after inspection");
+	await mkdir(freshDirectory, { mode: 448 });
+	for (const file of tree.files) {
+		const path = join(freshDirectory, safeArchivePath(file.path));
+		await mkdir(dirname(path), {
+			recursive: true,
+			mode: 448
+		});
+		await writeFile(path, file.content, {
+			flag: "wx",
+			mode: file.executable ? 448 : 384
+		});
+	}
+}
+function segment(value) {
+	if (!value || value === "." || value === ".." || /[\s/\\\u0000-\u001f\u007f]/u.test(value)) throw new Error("Invalid package path segment");
+	return encodeURIComponent(value);
+}
+var PluginRegistryClient = class {
+	registry;
+	token;
+	constructor(registry, token = null) {
+		this.registry = normalizeRegistry(registry);
+		this.token = token;
+	}
+	base(namespace, slug) {
+		return `/namespaces/${segment(namespace)}/packages/${segment(slug)}`;
+	}
+	async bytes(path, maximum) {
+		if (!Number.isSafeInteger(maximum) || maximum <= 0) throw new Error("Invalid response limit");
+		const url = new URL(`${this.registry}/api/v1${path}`);
+		return new Promise((resolve, reject) => {
+			const request = (url.protocol === "https:" ? https : http).get(url, {
+				headers: this.token ? { Authorization: `Bearer ${this.token}` } : {},
+				rejectUnauthorized: true
+			}, (response) => {
+				if (response.statusCode !== 200) {
+					reject(/* @__PURE__ */ new Error(`Plugin registry HTTP ${response.statusCode ?? 0}`));
+					response.destroy();
+					return;
+				}
+				if (Number(response.headers["content-length"] ?? 0) > maximum) {
+					reject(/* @__PURE__ */ new Error("Plugin response limit exceeded"));
+					response.destroy();
+					return;
+				}
+				let size = 0;
+				const chunks = [];
+				response.on("data", (chunk) => {
+					size += chunk.length;
+					if (size > maximum) {
+						reject(/* @__PURE__ */ new Error("Plugin response limit exceeded"));
+						response.destroy();
+						return;
+					}
+					chunks.push(chunk);
+				});
+				response.on("end", () => resolve(Buffer.concat(chunks)));
+				response.on("error", reject);
+				response.on("aborted", () => reject(/* @__PURE__ */ new Error("Plugin response interrupted")));
+			});
+			const timeout = setTimeout(() => request.destroy(/* @__PURE__ */ new Error("Plugin request timed out")), 3e4);
+			request.on("close", () => clearTimeout(timeout));
+			request.on("error", reject);
+		});
+	}
+	async json(path) {
+		const bytes = await this.bytes(path, 8 * 1024 ** 2);
+		try {
+			const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+			if (!parsed || typeof parsed !== "object" || !Object.hasOwn(parsed, "data") || parsed.data == null) throw new Error();
+			return parsed.data;
+		} catch {
+			throw new Error("Invalid plugin registry response");
+		}
+	}
+	async packageId(namespace, slug) {
+		const value = await this.json(this.base(namespace, slug));
+		const identifier = typeof value.id === "string" ? value.id : Number.isSafeInteger(value.id) ? String(value.id) : "";
+		if (!/^[1-9][0-9]*$/u.test(identifier)) throw new Error("Package identity is not an exact ID");
+		return identifier;
+	}
+	async summary(namespace, slug) {
+		return this.json(`${this.base(namespace, slug)}/plugin`);
+	}
+	async release(namespace, slug, version) {
+		return this.json(`${this.base(namespace, slug)}/plugin/releases/${segment(version)}`);
+	}
+	async download(namespace, slug, version, maximum = pluginArchiveLimits.compressedBytes) {
+		return this.bytes(`${this.base(namespace, slug)}/plugin/releases/${segment(version)}/download`, maximum);
+	}
+};
+export { PluginInstallRecords, PluginRegistryClient, inspectPluginArchive, materializePluginTree, normalizeRegistry, pluginArchiveLimits, pluginInstallKey, pluginSlotKey, selectPluginRoot, sha256, treeDigest };

package/dist/_chunks/rolldown-runtime.mjs

@@ -25,7 +25,7 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));

package/dist/_chunks/skills.mjs

@@ -127,7 +127,8 @@ async function readSkillLock() {
 async function writeSkillLock(lock) {
 	const lockPath = getSkillLockPath();
 	await mkdir(dirname(lockPath), { recursive: true });
-	await writeFile(lockPath, JSON.stringify(lock, null, 2), "utf-8");
+	const content = JSON.stringify(lock, null, 2);
+	await writeFile(lockPath, content, "utf-8");
 }
 let _ghWarningShown = false;
 function getGitHubToken() {
@@ -220,7 +221,8 @@ async function writeLocalLock(lock, cwd) {
 		version: lock.version,
 		skills: sortedSkills
 	};
-	await writeFile(lockPath, JSON.stringify(sorted, null, 2) + "\n", "utf-8");
+	const content = JSON.stringify(sorted, null, 2) + "\n";
+	await writeFile(lockPath, content, "utf-8");
 }
 async function computeSkillFolderHash(skillDir) {
 	const files = [];
@@ -308,7 +310,8 @@ function shouldInstallInternalSkills() {
 }
 async function hasSkillMd(dir) {
 	try {
-		return (await stat(join(dir, "SKILL.md"))).isFile();
+		const skillPath = join(dir, "SKILL.md");
+		return (await stat(skillPath)).isFile();
 	} catch {
 		return false;
 	}

package/dist/cli.d.mts

@@ -1 +1 @@
-export { };
+export {}