bip-skills 1.4.8 → 1.4.9

package/dist/cli.mjs

@@ -17,7 +17,10 @@ import { createHash } from "crypto";
 import { fileURLToPath } from "url";
 import * as readline from "readline";
 import { Writable } from "stream";
+import { Buffer } from "node:buffer";
 import { access, cp, lstat, mkdir, mkdtemp, readFile, readdir, readlink, realpath, rm, stat, symlink, writeFile } from "fs/promises";
+import http from "node:http";
+import https from "node:https";
 var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
 const AGENTS_DIR$2 = ".agents";
 const SKILLS_SUBDIR = "skills";
@@ -31,9 +34,13 @@ const DEFAULT_GIT_HOST = "git.yyrd.com";
 const DEFAULT_GIT_BASE_URL = `https://${DEFAULT_GIT_HOST}`;
 const DEFAULT_GIT_FALLBACK_SSH_HOST = "git.yyrd.com";
 const DEFAULT_INSTALL_REPORT_URL = "https://sun.yyuap.com/api/install-report";
+const TLS_RELAXED_HOSTS = ["sun.yyuap.com"];
 function isYyuapHost(hostname) {
 	return hostname === "yyuap.com" || hostname.endsWith(".yyuap.com");
 }
+function shouldRelaxTlsForHost(hostname) {
+	return TLS_RELAXED_HOSTS.includes(hostname);
+}
 function isYyrdHost(hostname) {
 	return hostname === "yyrd.com" || hostname.endsWith(".yyrd.com");
 }
@@ -515,13 +522,41 @@ async function hasSkillMd(dir) {
 		return false;
 	}
 }
+function getYamlHeuristicHint(content, frontmatterKeys) {
+	if (frontmatterKeys.length > 0 || !content.startsWith("---\n")) return null;
+	const closingMarkerIndex = content.indexOf("\n---", 4);
+	if (closingMarkerIndex === -1) return "frontmatter start marker was found, but the closing --- marker may be missing or malformed";
+	const suspiciousLine = content.slice(4, closingMarkerIndex).split(/\r?\n/).find((line) => /^[A-Za-z0-9_-]+:\s.+:\s/.test(line) && !/^[A-Za-z0-9_-]+:\s*["'|>]/.test(line));
+	if (suspiciousLine) return `frontmatter looks present but YAML may be invalid; this line contains an unquoted ": " inside a scalar value: ${JSON.stringify(suspiciousLine)}`;
+	return "frontmatter looks present but YAML parsing produced no keys; check for hidden characters, invalid YAML syntax, or unquoted \": \" inside values";
+}
 async function parseSkillMd(skillMdPath, options) {
 	try {
 		const content = await readFile(skillMdPath, "utf-8");
 		const { data } = (0, import_gray_matter.default)(content);
-		if (!data.name || !data.description) return null;
-		if (typeof data.name !== "string" || typeof data.description !== "string") return null;
-		if (data.metadata?.internal === true && !shouldInstallInternalSkills() && !options?.includeInternal) return null;
+		const frontmatterKeys = Object.keys(data);
+		const frontmatterSummary = frontmatterKeys.length === 0 ? "(none)" : frontmatterKeys.map((key) => {
+			const value = data[key];
+			return `${key}:${Array.isArray(value) ? "array" : typeof value}`;
+		}).join(", ");
+		const leadingPreview = JSON.stringify(content.slice(0, 80));
+		const firstLine = JSON.stringify(content.split(/\r?\n/, 1)[0] ?? "");
+		const leadingCharCodes = Array.from(content.slice(0, 8)).map((char) => `U+${char.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")}`).join(", ");
+		const heuristicHint = getYamlHeuristicHint(content, frontmatterKeys);
+		if (!data.name || !data.description) {
+			debugLog(`[discover] skipped ${skillMdPath}: missing required frontmatter fields "name" and/or "description" (parsed keys: ${frontmatterSummary}, firstLine: ${firstLine}, leadingChars: ${leadingCharCodes}, leadingPreview: ${leadingPreview})`);
+			if (heuristicHint) debugLog(`[discover] hint ${skillMdPath}: ${heuristicHint}`);
+			return null;
+		}
+		if (typeof data.name !== "string" || typeof data.description !== "string") {
+			debugLog(`[discover] skipped ${skillMdPath}: frontmatter "name" and "description" must be strings (name=${typeof data.name}, description=${typeof data.description}, parsed keys: ${frontmatterSummary})`);
+			return null;
+		}
+		if (data.metadata?.internal === true && !shouldInstallInternalSkills() && !options?.includeInternal) {
+			debugLog(`[discover] skipped ${skillMdPath}: internal skill hidden (set INSTALL_INTERNAL_SKILLS=1 or request it explicitly)`);
+			return null;
+		}
+		debugLog(`[discover] accepted ${skillMdPath}: name="${data.name}" (parsed keys: ${frontmatterSummary})`);
 		return {
 			name: data.name,
 			description: data.description,
@@ -529,7 +564,8 @@ async function parseSkillMd(skillMdPath, options) {
 			rawContent: content,
 			metadata: data.metadata
 		};
-	} catch {
+	} catch (error) {
+		debugLog(`[discover] failed to read ${skillMdPath}: ${error instanceof Error ? error.message : String(error)}`);
 		return null;
 	}
 }
@@ -548,6 +584,7 @@ async function discoverSkills(basePath, subpath, options) {
 	const skills = [];
 	const seenNames = /* @__PURE__ */ new Set();
 	const searchPath = subpath ? join(basePath, subpath) : basePath;
+	debugLog(`[discover] start basePath=${basePath} searchPath=${searchPath} includeInternal=${options?.includeInternal === true} fullDepth=${options?.fullDepth === true}`);
 	const pluginGroupings = await getPluginGroupings(searchPath);
 	const enhanceSkill = (skill) => {
 		const resolvedPath = resolve(skill.path);
@@ -555,6 +592,7 @@ async function discoverSkills(basePath, subpath, options) {
 		return skill;
 	};
 	if (await hasSkillMd(searchPath)) {
+		debugLog(`[discover] found root SKILL.md at ${join(searchPath, "SKILL.md")}`);
 		let skill = await parseSkillMd(join(searchPath, "SKILL.md"), options);
 		if (skill) {
 			skill = enhanceSkill(skill);
@@ -595,31 +633,38 @@ async function discoverSkills(basePath, subpath, options) {
 		join(searchPath, ".zencoder/skills")
 	];
 	prioritySearchDirs.push(...await getPluginSkillPaths(searchPath));
+	debugLog(`[discover] scanning priority directories (${prioritySearchDirs.length}): ${prioritySearchDirs.join(", ")}`);
 	for (const dir of prioritySearchDirs) try {
 		const entries = await readdir(dir, { withFileTypes: true });
 		for (const entry of entries) if (entry.isDirectory()) {
 			const skillDir = join(dir, entry.name);
 			if (await hasSkillMd(skillDir)) {
+				debugLog(`[discover] candidate skill directory ${skillDir}`);
 				let skill = await parseSkillMd(join(skillDir, "SKILL.md"), options);
 				if (skill && !seenNames.has(skill.name)) {
 					skill = enhanceSkill(skill);
 					skills.push(skill);
 					seenNames.add(skill.name);
-				}
+				} else if (skill) debugLog(`[discover] skipped ${join(skillDir, "SKILL.md")}: duplicate skill name "${skill.name}"`);
 			}
 		}
-	} catch {}
+	} catch (error) {
+		debugLog(`[discover] unable to scan ${dir}: ${error instanceof Error ? error.message : String(error)}`);
+	}
 	if (skills.length === 0 || options?.fullDepth) {
+		debugLog(`[discover] ${skills.length === 0 ? "no skills from priority scan" : "fullDepth enabled"}; starting recursive search from ${searchPath}`);
 		const allSkillDirs = await findSkillDirs(searchPath);
+		debugLog(`[discover] recursive candidates (${allSkillDirs.length}): ${allSkillDirs.join(", ") || "(none)"}`);
 		for (const skillDir of allSkillDirs) {
 			let skill = await parseSkillMd(join(skillDir, "SKILL.md"), options);
 			if (skill && !seenNames.has(skill.name)) {
 				skill = enhanceSkill(skill);
 				skills.push(skill);
 				seenNames.add(skill.name);
-			}
+			} else if (skill) debugLog(`[discover] skipped ${join(skillDir, "SKILL.md")}: duplicate skill name "${skill.name}"`);
 		}
 	}
+	debugLog(`[discover] completed searchPath=${searchPath}; found ${skills.length} skill${skills.length === 1 ? "" : "s"}`);
 	return skills;
 }
 function getSkillDisplayName(skill) {
@@ -1411,6 +1456,106 @@ async function listInstalledSkills(options = {}) {
 	} catch {}
 	return Array.from(skillsMap.values());
 }
+function getRequestUrl(input) {
+	if (input instanceof URL) return input;
+	if (typeof input === "string") return new URL(input);
+	return new URL(input.url);
+}
+function shouldUseRelaxedTls(input) {
+	try {
+		const url = getRequestUrl(input);
+		return url.protocol === "https:" && shouldRelaxTlsForHost(url.hostname);
+	} catch {
+		return false;
+	}
+}
+function normalizeRequestMethod(input, init) {
+	if (init?.method) return init.method.toUpperCase();
+	if (typeof Request !== "undefined" && input instanceof Request) return input.method.toUpperCase();
+	return "GET";
+}
+function buildHeaders(input, init) {
+	const headers = new Headers(typeof Request !== "undefined" && input instanceof Request ? input.headers : void 0);
+	if (init?.headers) new Headers(init.headers).forEach((value, key) => {
+		headers.set(key, value);
+	});
+	return headers;
+}
+async function readRequestBody(init) {
+	const body = init?.body;
+	if (body == null) return;
+	if (typeof body === "string") return Buffer.from(body);
+	if (body instanceof URLSearchParams) return Buffer.from(body.toString());
+	if (body instanceof ArrayBuffer) return Buffer.from(body);
+	if (ArrayBuffer.isView(body)) return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+	if (body instanceof Blob) return Buffer.from(await body.arrayBuffer());
+	throw new TypeError("Unsupported request body for relaxed TLS fetch");
+}
+async function relaxedTlsFetch(input, init, redirectCount = 0) {
+	if (redirectCount > 5) throw new Error("Too many redirects");
+	const url = getRequestUrl(input);
+	const method = normalizeRequestMethod(input, init);
+	const headers = buildHeaders(input, init);
+	const body = await readRequestBody(init);
+	const transport = url.protocol === "https:" ? https : http;
+	return await new Promise((resolve, reject) => {
+		const request = transport.request(url, {
+			method,
+			headers: Object.fromEntries(headers.entries()),
+			rejectUnauthorized: url.protocol === "https:" ? false : void 0
+		}, (response) => {
+			const status = response.statusCode ?? 500;
+			const location = response.headers.location;
+			if (location && [
+				301,
+				302,
+				303,
+				307,
+				308
+			].includes(status) && init?.redirect !== "manual") {
+				response.resume();
+				const nextUrl = new URL(location, url);
+				const nextInit = {
+					...init,
+					method: status === 303 ? "GET" : method
+				};
+				delete nextInit.body;
+				relaxedTlsFetch(nextUrl, nextInit, redirectCount + 1).then(resolve).catch(reject);
+				return;
+			}
+			const chunks = [];
+			response.on("data", (chunk) => {
+				chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+			});
+			response.on("end", () => {
+				const responseHeaders = Object.entries(response.headers).flatMap(([key, value]) => value == null ? [] : Array.isArray(value) ? value.map((item) => [key, item]) : [[key, value]]);
+				resolve(new Response(method === "HEAD" ? null : Buffer.concat(chunks), {
+					status,
+					statusText: response.statusMessage ?? "",
+					headers: new Headers(responseHeaders)
+				}));
+			});
+		});
+		request.on("error", reject);
+		if (init?.signal) {
+			const abort = () => {
+				request.destroy(new DOMException("The operation was aborted.", "AbortError"));
+			};
+			if (init.signal.aborted) {
+				abort();
+				return;
+			}
+			init.signal.addEventListener("abort", abort, { once: true });
+			request.on("close", () => init.signal?.removeEventListener("abort", abort));
+		}
+		if (body) request.write(body);
+		request.end();
+	});
+}
+async function fetchWithSelectiveTls(input, init) {
+	if (!shouldUseRelaxedTls(input)) return fetch(input, init);
+	return relaxedTlsFetch(input, init);
+}
 function getAllowedReportingUrl(envVarName) {
 	const value = process.env[envVarName];
 	if (!value) return null;
@@ -1439,7 +1584,7 @@ async function fetchAuditData(source, skillSlugs, timeoutMs = 3e3) {
 		});
 		const controller = new AbortController();
 		const timeout = setTimeout(() => controller.abort(), timeoutMs);
-		const response = await fetch(`${AUDIT_URL}?${params.toString()}`, { signal: controller.signal });
+		const response = await fetchWithSelectiveTls(`${AUDIT_URL}?${params.toString()}`, { signal: controller.signal });
 		clearTimeout(timeout);
 		if (!response.ok) return null;
 		return await response.json();
@@ -1454,7 +1599,7 @@ function sendTelemetry(url, data) {
 		if (cliVersion) params.set("v", cliVersion);
 		if (isCI()) params.set("ci", "1");
 		for (const [key, value] of Object.entries(data)) if (value !== void 0 && value !== null) params.set(key, String(value));
-		fetch(`${url}?${params.toString()}`).catch(() => {});
+		fetchWithSelectiveTls(`${url}?${params.toString()}`).catch(() => {});
 	} catch {}
 }
 function track(data) {
@@ -1566,7 +1711,7 @@ var WellKnownProvider = class {
 			});
 			for (const { indexUrl, baseUrl: resolvedBase } of urlsToTry) try {
 				debugLog(`[well-known] requesting index: ${indexUrl}`);
-				const response = await fetch(indexUrl);
+				const response = await fetchWithSelectiveTls(indexUrl);
 				if (!response.ok) {
 					debugLog(`[well-known] index response status: ${response.status} ${response.statusText}`);
 					continue;
@@ -1650,7 +1795,7 @@ var WellKnownProvider = class {
 				indexEntry: entry,
 				installTarget
 			};
-			const response = await fetch(installTarget.skillMdUrl);
+			const response = await fetchWithSelectiveTls(installTarget.skillMdUrl);
 			if (!response.ok) return null;
 			const content = await response.text();
 			const { data } = (0, import_gray_matter.default)(content);
@@ -1660,8 +1805,7 @@ var WellKnownProvider = class {
 				try {
 					const normalizedFilePath = filePath.replace(/^\/+/, "");
 					const fileRelativePath = installTarget.skillRoot ? posix.join(installTarget.skillRoot, normalizedFilePath) : normalizedFilePath;
-					const fileUrl = this.buildUrl(this.resolveInlineBaseUrl(installTarget.repositoryUrl) || baseUrl, fileRelativePath);
-					const fileResponse = await fetch(fileUrl);
+					const fileResponse = await fetchWithSelectiveTls(this.buildUrl(this.resolveInlineBaseUrl(installTarget.repositoryUrl) || baseUrl, fileRelativePath));
 					if (fileResponse.ok) return {
 						path: normalizedFilePath,
 						content: await fileResponse.text()
@@ -1926,7 +2070,7 @@ function createEmptyLocalLock() {
 		skills: {}
 	};
 }
-var version$1 = "1.4.8";
+var version$1 = "1.4.9";
 const isCancelled$1 = (value) => typeof value === "symbol";
 async function isSourcePrivate(source) {
 	const ownerRepo = parseOwnerRepo(source);
@@ -2590,6 +2734,7 @@ async function runAdd(args, options = {}) {
 			fullDepth: options.fullDepth
 		});
 		if (skills.length === 0) {
+			debugLog(`[add] discoverSkills returned 0 skills for source=${parsed.type === "local" ? parsed.localPath : parsed.url} searchSubpath=${parsed.subpath ?? "(root)"} includeInternal=${includeInternal} fullDepth=${options.fullDepth === true}`);
 			spinner.stop(import_picocolors.default.red("No skills found"));
 			Se(import_picocolors.default.red("No valid skills found. Skills require a SKILL.md with name and description."));
 			await cleanup(tempDir);
@@ -3145,7 +3290,7 @@ async function searchSkillsAPI(query) {
 	try {
 		const url = `${SEARCH_API_BASE}/api/search?q=${encodeURIComponent(query)}&limit=10`;
 		debugLog(`[find] requesting search: ${url}`);
-		const res = await fetch(url);
+		const res = await fetchWithSelectiveTls(url);
 		debugLog(`[find] search response status: ${res.status} ${res.statusText}`);
 		const responseText = await res.text();
 		debugLog(`[find] search response body: ${responseText}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bip-skills",
-  "version": "1.4.8",
+  "version": "1.4.9",
   "description": "The open agent skills ecosystem",
   "type": "module",
   "bin": {