bfi-cli 0.1.99 → 0.1.101

package/dist/_chunks/digest.mjs

@@ -0,0 +1,132 @@
+import { normalizeConfig } from "./model.mjs";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+const identifier = z.string().min(1).max(256);
+const digest = z.string().regex(/^[a-f0-9]{64}$/);
+const relativePath = z.string().min(1).max(1024).refine((value) => !/[\\\x00-\x1f:%]/.test(value) && value.split("/").every((part) => part !== "" && part !== "." && part !== ".."));
+const registry = z.string().url().refine((value) => {
+	const url = new URL(value);
+	return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password && !url.search && !url.hash;
+});
+const contentPlanSchema = z.object({
+	schemaVersion: z.literal(1),
+	id: identifier,
+	registry,
+	kind: z.enum(["SKILL", "COLLECTION"]),
+	resourceId: identifier,
+	ref: z.string().regex(/^@[a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+$/),
+	contentRevision: z.number().int().nonnegative().safe().optional(),
+	expiresAt: z.string().datetime(),
+	manifestDigest: digest,
+	requiredCapabilities: z.array(identifier).max(64),
+	skills: z.array(z.object({
+		id: identifier,
+		ref: identifier,
+		versionId: identifier,
+		version: identifier,
+		root: relativePath,
+		digest
+	}).strict()).min(1).max(1e3),
+	mcps: z.array(z.object({
+		id: identifier,
+		revision: z.number().int().nonnegative().safe(),
+		registrationName: identifier,
+		config: z.record(z.unknown()).refine((value) => {
+			try {
+				normalizeConfig(value);
+				return true;
+			} catch {
+				return false;
+			}
+		}),
+		inputs: z.array(z.object({
+			key: identifier,
+			required: z.boolean(),
+			sensitive: z.boolean(),
+			description: z.string().max(2048).optional()
+		}).strict()).max(128),
+		runtime: z.record(z.unknown()).optional(),
+		digest
+	}).strict()).max(1e3),
+	files: z.array(z.object({
+		path: relativePath,
+		size: z.number().int().nonnegative().max(52428800),
+		sha256: digest,
+		executable: z.boolean()
+	}).strict()).min(1).max(2e4)
+}).strict();
+function hasLiteralSecret(value, sensitiveKeys) {
+	if (!value || typeof value !== "object") return false;
+	const isSensitive = (key) => sensitiveKeys.has(key.toLowerCase()) || /(token|secret|password|credential|authorization|api[_-]?key|(?:^|[_-])(?:ak|sk)$)/i.test(key);
+	const isReference = (entry) => typeof entry === "string" && /^(?:Bearer )?\$\{[a-zA-Z_][\w.]*\}$/.test(entry);
+	if (Array.isArray(value)) return value.some((entry, index) => {
+		if (typeof entry !== "string") return hasLiteralSecret(entry, sensitiveKeys);
+		const flag = entry.match(/^--?([^=\s]+)(?:=(.*))?$/);
+		if (flag && isSensitive(flag[1])) return !isReference(flag[2] ?? value[index + 1]);
+		const assignment = entry.match(/^([A-Za-z_][\w-]*)[:=]\s*(.*)$/);
+		return Boolean(assignment && isSensitive(assignment[1]) && !isReference(assignment[2]));
+	});
+	return Object.entries(value).some(([key, entry]) => {
+		if (isSensitive(key)) return !isReference(entry);
+		if (typeof entry === "string") {
+			if (key === "url") try {
+				const url = new URL(entry);
+				return Boolean(url.username || url.password || [...url.searchParams.keys()].some((param) => /token|secret|key|password/i.test(param)));
+			} catch {
+				return true;
+			}
+		}
+		return hasLiteralSecret(entry, sensitiveKeys);
+	});
+}
+function parseContentPlan(value) {
+	const parsed = contentPlanSchema.safeParse(value);
+	const invalid = () => {
+		throw new Error("INVALID_CONTENT_PLAN");
+	};
+	if (!parsed.success) return invalid();
+	const plan = parsed.data;
+	const roots = plan.skills.map((skill) => skill.root.normalize("NFC").toLowerCase());
+	const paths = plan.files.map((file) => file.path.normalize("NFC").toLowerCase());
+	const pathSet = new Set(paths);
+	const unique = (values) => new Set(values).size === values.length;
+	if (!unique(paths) || paths.some((path) => {
+		let parent = path;
+		while (parent.includes("/")) {
+			parent = parent.slice(0, parent.lastIndexOf("/"));
+			if (pathSet.has(parent)) return true;
+		}
+		return false;
+	}) || !unique(plan.skills.map((skill) => skill.id)) || !unique(plan.mcps.map((mcp) => mcp.id)) || !unique(plan.mcps.map((mcp) => mcp.registrationName.toLowerCase())) || plan.files.reduce((size, file) => size + file.size, 0) > 524288e3 || plan.kind === "SKILL" && (plan.skills.length !== 1 || plan.mcps.length !== 0)) return invalid();
+	if (roots.some((root, index) => roots.some((other, otherIndex) => index !== otherIndex && (root === other || root.startsWith(`${other}/`))))) return invalid();
+	if (plan.skills.some((skill) => !plan.files.some((file) => file.path === `${skill.root}/SKILL.md`)) || plan.files.some((file) => !plan.skills.some((skill) => file.path.startsWith(`${skill.root}/`)))) return invalid();
+	if (plan.mcps.some((mcp) => {
+		const sensitiveKeys = new Set(mcp.inputs.filter((input) => input.sensitive).map((input) => input.key.toLowerCase()));
+		return hasLiteralSecret(mcp.config, sensitiveKeys) || hasLiteralSecret(mcp.runtime, sensitiveKeys) || !unique(mcp.inputs.map((input) => input.key));
+	})) return invalid();
+	return plan;
+}
+function canonical(value) {
+	if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+function hash(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function stableManifest(plan) {
+	const { id, expiresAt, ...stable } = plan;
+	return stable;
+}
+function verifyPlan(value) {
+	const plan = parseContentPlan(value);
+	const { manifestDigest, ...content } = stableManifest(plan);
+	if (hash(canonical(content)) !== manifestDigest) throw new Error("内容计划摘要不匹配。");
+	for (const skill of plan.skills) if (hash(canonical(plan.files.filter((file) => file.path.startsWith(`${skill.root}/`)))) !== skill.digest) throw new Error("技能摘要不匹配。");
+	for (const mcp of plan.mcps) {
+		const { digest, ...entry } = mcp;
+		if (hash(canonical(entry)) !== digest) throw new Error("MCP 摘要不匹配。");
+	}
+	return plan;
+}
+export { canonical, hash, stableManifest, verifyPlan };

package/dist/_chunks/files.mjs

@@ -0,0 +1,89 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { dirname, parse, resolve } from "node:path";
+import { lstat, mkdir, open, rename, unlink } from "node:fs/promises";
+async function checkPath(filename) {
+	let current = resolve(filename);
+	while (current !== parse(current).root) {
+		try {
+			const stat = await lstat(current);
+			if (stat.isSymbolicLink() || current === resolve(filename) && (!stat.isFile() || stat.nlink > 1)) throw new Error("配置路径含符号链接、特殊文件或硬链接，拒绝写入。");
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		current = dirname(current);
+	}
+}
+async function readConfig(filename) {
+	await checkPath(filename);
+	try {
+		const handle = await open(filename, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+		try {
+			const stat = await handle.stat();
+			if (!stat.isFile() || stat.size > 2097152) throw new Error("配置文件不是普通文件或超过 2 MiB。");
+			return await handle.readFile("utf8");
+		} finally {
+			await handle.close();
+		}
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+}
+async function identity(filename) {
+	try {
+		const stat = await lstat(filename, { bigint: true });
+		return `${stat.dev}:${stat.ino}:${stat.mode}:${stat.mtimeNs}:${stat.size}`;
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+}
+async function writeConfig(filename, previous, next, expectedIdentity) {
+	if (previous === next) return;
+	await checkPath(filename);
+	const originalIdentity = expectedIdentity ?? await identity(filename);
+	if (previous !== void 0 && ((await lstat(filename)).mode & 128) === 0) throw new Error("配置文件只读，不放宽其权限。");
+	await mkdir(dirname(filename), {
+		recursive: true,
+		mode: 448
+	});
+	const lockPath = `${filename}.bfi-mcp.lock`;
+	const temporary = `${filename}.bfi-mcp-${randomUUID()}.tmp`;
+	const backup = previous === void 0 ? void 0 : `${filename}.bfi-mcp-${Date.now()}-${randomUUID()}.bak`;
+	let lock;
+	try {
+		lock = await open(lockPath, "wx", 384);
+	} catch {
+		throw new Error("无法取得配置写入锁。可能有其它安装正在进行；请核对残留 .bfi-mcp.lock 后重试。");
+	}
+	try {
+		await checkPath(filename);
+		if (await readConfig(filename) !== previous || await identity(filename) !== originalIdentity) throw new Error("配置已被其它进程修改，请重新预览并重试。");
+		if (backup) {
+			const handle = await open(backup, "wx", 384);
+			try {
+				await handle.writeFile(previous, "utf8");
+				await handle.sync();
+			} finally {
+				await handle.close();
+			}
+		}
+		const handle = await open(temporary, "wx", 384);
+		try {
+			await handle.writeFile(next, "utf8");
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+		await checkPath(filename);
+		if (await readConfig(filename) !== previous || await identity(filename) !== originalIdentity) throw new Error("写入前检测到并发修改，已取消。");
+		await rename(temporary, filename);
+		return backup;
+	} finally {
+		await unlink(temporary).catch(() => {});
+		await lock.close().catch(() => {});
+		await unlink(lockPath).catch(() => {});
+	}
+}
+export { checkPath, identity, readConfig, writeConfig };

package/dist/_chunks/{registry-client.mjs → intent.mjs}

@@ -248,9 +248,9 @@ function checkCredentials(file) {
 		"id_ed25519",
 		".credentials.json",
 		"credentials"
-	].includes(basename) || lower.startsWith(".git/") || lower.includes("/.git/")) throw new Error("Archive contains a credential or repository-private file");
+	].includes(basename) || lower.startsWith(".git/") || lower.includes("/.git/")) throw new Error(`Archive contains a credential or repository-private file (${file.path})`);
 	const text = file.content.toString("utf8");
-	checkCredentialText(text);
+	checkCredentialText(file.path, text);
 	if (lower.endsWith(".json")) {
 		let decoded;
 		try {
@@ -258,18 +258,62 @@ function checkCredentials(file) {
 		} catch {
 			return;
 		}
-		checkCredentialText(JSON.stringify(decoded));
+		checkCredentialText(file.path, 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 checkCredentialText(path, text) {
+	if (/(?<![A-Za-z0-9_-])(?:AKIA[0-9A-Z]{16}|gh[pousr]_[A-Za-z0-9]{20,}|sk-[A-Za-z0-9_-]{20,})(?![A-Za-z0-9_-])|-----BEGIN (?:[A-Z ]+ )?PRIVATE KEY-----/u.test(text)) throw new Error(`Archive contains a credential literal (${path})`);
+	const regions = credentialCodeRegions(path, text);
+	const expression = /(?<![A-Za-z0-9_$])(?:[A-Za-z][A-Za-z0-9_-]*)?(?:api[_-]?key|access[_-]?key|secret(?:[_-]?key)?|password|token|authorization|x-pm-[as]k)["']?\s*[:=]\s*(?:"((?:\\.|[^\\"\r\n]){12,})"|'((?:\\.|[^\\'\r\n]){12,})'|(?:Bearer\s+)?([A-Za-z0-9_./+=!@#$%^&*?:<>|~-]{12,})(?=\s*(?:$|[,;}\r\n"'])))/giu;
+	let regionIndex = 0;
+	for (const match of text.matchAll(expression)) {
+		while (regionIndex < regions.length && regions[regionIndex].end <= match.index) regionIndex++;
+		const region = regions[regionIndex];
+		const value = match[1] ?? match[2] ?? match[3];
+		if (region && region.start <= match.index && match.index + match[0].length <= region.end && match[3] !== void 0 && !/\bBearer\s/iu.test(match[0]) && !value.startsWith("eyJ") && /^[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)+$/u.test(value)) continue;
+		const literal = value.replace(/^Bearer\s+/iu, "");
+		if (/^(?:\$\{[^{}\r\n]+\}|\$[A-Za-z_][A-Za-z0-9_]*)$/u.test(literal)) continue;
+		if ([
+			"YOUR_API_KEY",
+			"YOUR_ACCESS_TOKEN",
+			"YOUR_PASSWORD",
+			"REPLACE_ME"
+		].includes(literal.replace(/-/gu, "_").toUpperCase()) || [
+			"placeholder",
+			"literal_token",
+			"加密后的clientSecret"
+		].includes(literal)) continue;
+		throw new Error(`Archive contains a possible credential literal (${path})`);
+	}
+}
+function credentialCodeRegions(path, text) {
+	if (/\.(?:[cm]?[jt]sx?|py|java|go|rs)$/iu.test(path)) return [{
+		start: 0,
+		end: text.length
+	}];
+	if (!/\.(?:md|markdown)$/iu.test(path)) return [];
+	const regions = [];
+	let opening;
+	for (const fence of text.matchAll(/^ {0,3}(`{3,}|~{3,})([^\r\n]*)\r?$/gmu)) {
+		const marker = fence[1], language = fence[2].trim();
+		if (!opening) opening = {
+			marker,
+			start: fence.index + fence[0].length,
+			code: /^(?:[cm]?js|javascript|jsx|ts|typescript|tsx|py|python|java|go|rs|rust)$/iu.test(language)
+		};
+		else if (marker[0] === opening.marker[0] && marker.length >= opening.marker.length && !language) {
+			if (opening.code) regions.push({
+				start: opening.start,
+				end: fence.index
+			});
+			opening = void 0;
+		}
+	}
+	if (opening?.code) regions.push({
+		start: opening.start,
+		end: text.length
+	});
+	return regions;
 }
 function treeDigest(files) {
 	const digest = createHash("sha256");
@@ -532,4 +576,110 @@ var PluginRegistryClient = class {
 		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 };
+const pluginTargets = [
+	"claude-code",
+	"codex",
+	"zcode",
+	"codebuddy",
+	"qwen-code"
+];
+const isPluginArchive = (value) => /\.(zip|tgz|tar\.gz)$/iu.test(value);
+const isPluginVersion = (value) => /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(?:-(?:0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u.test(value);
+function parsePackageIntent(args) {
+	const output = [...args];
+	let mode = "skills";
+	const occurrences = args.filter((value) => value === "--as" || value.startsWith("--as="));
+	if (occurrences.length) {
+		const index = output.indexOf("--as");
+		const requested = output[index + 1];
+		if (occurrences.length !== 1 || index < 0 || !["skills", "plugin"].includes(requested ?? "")) throw new Error("Use --as skills or --as plugin exactly once; upgrade bfi if this option is unavailable");
+		mode = requested;
+		output.splice(index, 2);
+	}
+	if (mode === "skills" && (output.some((value) => [
+		"--plan",
+		"--export",
+		"--prepare-native",
+		"--scope",
+		"--root",
+		"--operation"
+	].includes(value) || /^(--plan|--export|--prepare-native|--scope|--root|--operation)=/u.test(value)) || isPluginArchive(output[1] ?? ""))) throw new Error("Plugin archives and plugin options require explicit --as plugin; no skills were installed");
+	return {
+		mode,
+		args: output
+	};
+}
+function parsePluginArguments(args) {
+	const command = {
+		install: "install",
+		i: "install",
+		update: "update",
+		up: "update",
+		uninstall: "uninstall",
+		rm: "uninstall",
+		list: "list",
+		ls: "list"
+	}[args[0] ?? ""];
+	if (!command) throw new Error("Plugin intent supports install, update, uninstall and list");
+	const result = {
+		command,
+		scope: "project",
+		planOnly: false,
+		json: false
+	};
+	const seen = /* @__PURE__ */ new Set();
+	const values = /* @__PURE__ */ new Set([
+		"--agent",
+		"--version",
+		"--scope",
+		"--root",
+		"--export",
+		"--prepare-native",
+		"--operation",
+		"--registry",
+		"--token",
+		"--namespace"
+	]);
+	for (let index = 1; index < args.length; index++) {
+		const option = args[index];
+		if (!option.startsWith("-")) {
+			if (result.source) throw new Error("Specify exactly one plugin source");
+			result.source = option;
+			continue;
+		}
+		const flag = option === "-g" ? "--global" : option === "-y" ? "--yes" : option;
+		if (seen.has(flag)) throw new Error(`Duplicate plugin option: ${flag}`);
+		seen.add(flag);
+		if (values.has(flag)) {
+			const value = args[++index];
+			if (value === void 0 || value.startsWith("-") || /[\u0000-\u001f\u007f]/u.test(value)) throw new Error(`Missing or invalid value for ${flag}`);
+			if (flag === "--agent") {
+				if (!pluginTargets.includes(value)) throw new Error("Unknown native plugin target");
+				result.agent = value;
+			} else if (flag === "--version") {
+				if (!isPluginVersion(value)) throw new Error("Plugin version must be exact SemVer, not latest or a range");
+				result.version = value;
+			} else if (flag === "--scope") {
+				if (!["project", "user"].includes(value)) throw new Error("Plugin scope must be project or user");
+				result.scope = value;
+			} else if (flag === "--root") result.root = value;
+			else if (flag === "--export") result.exportPath = value;
+			else if (flag === "--prepare-native") result.preparePath = value;
+			else if (flag === "--operation") result.operationId = value;
+		} else if (flag === "--global") result.scope = "user";
+		else if (flag === "--plan") result.planOnly = true;
+		else if (flag === "--json") result.json = true;
+		else if (flag === "--yes") result.confirmed = true;
+		else throw new Error(`Unknown plugin option: ${flag}; upgrade bfi if needed`);
+	}
+	if (seen.has("--scope") && seen.has("--global")) throw new Error("Use --scope or --global, not both");
+	result.scopeExplicit = seen.has("--scope") || seen.has("--global");
+	if (command !== "list" && !result.source && !(command === "uninstall" && result.operationId)) throw new Error("Specify @namespace/package or a local zip/tgz path");
+	if (result.source && !/^@[^/\s]+\/[^/\s]+$/u.test(result.source) && !isPluginArchive(result.source)) throw new Error("Use a namespace-qualified @namespace/package reference or local archive");
+	if (result.planOnly && result.exportPath) throw new Error("Plan and export are separate operations");
+	if (result.preparePath && (result.planOnly || result.exportPath || command !== "install")) throw new Error("Native handoff, plan and export are separate install operations");
+	if (result.root !== void 0 && !isPluginArchive(result.source ?? "") || result.operationId && command !== "uninstall" || (result.exportPath || result.root !== void 0) && command !== "install") throw new Error("Plugin option is invalid for this operation");
+	if (command === "list" && (result.source || result.version || result.planOnly || result.exportPath || result.operationId)) throw new Error("Invalid plugin list options");
+	return result;
+}
+export { PluginInstallRecords, PluginRegistryClient, inspectPluginArchive, isPluginArchive, isPluginVersion, materializePluginTree, normalizeRegistry, parsePackageIntent, parsePluginArguments, pluginArchiveLimits, pluginInstallKey, pluginSlotKey, pluginTargets, selectPluginRoot, sha256, treeDigest };