bip-skills 1.4.10 → 1.4.12

package/dist/cli.mjs

@@ -9,7 +9,7 @@ import { t as require_gray_matter } from "./_chunks/libs/gray-matter.mjs";
 import "./_chunks/libs/extend-shallow.mjs";
 import "./_chunks/libs/esprima.mjs";
 import { t as xdgConfig } from "./_chunks/libs/xdg-basedir.mjs";
-import { execSync, spawnSync } from "child_process";
+import { execFile, execSync, spawnSync } from "child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { basename, dirname, isAbsolute, join, normalize, posix, relative, resolve, sep } from "path";
 import { homedir, platform, tmpdir } from "os";
@@ -17,6 +17,7 @@ import { fileURLToPath } from "url";
 import * as readline from "readline";
 import { Writable } from "stream";
 import { Buffer } from "node:buffer";
+import { promisify } from "util";
 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";
@@ -103,7 +104,12 @@ function isInternalSkillSourceUrl(sourceUrl) {
 	return hostname ? isInternalSkillSourceHost(hostname) : false;
 }
 function isLocalPath(input) {
-	return isAbsolute(input) || input.startsWith("./") || input.startsWith("../") || input === "." || input === ".." || /^[a-zA-Z]:[/\\]/.test(input);
+	return isAbsolute(input) || input === "~" || input.startsWith("~/") || input.startsWith("~\\") || input.startsWith("./") || input.startsWith("../") || input === "." || input === ".." || /^[a-zA-Z]:[/\\]/.test(input);
+}
+function expandLocalPath(input) {
+	if (input === "~") return homedir();
+	if (input.startsWith("~/") || input.startsWith("~\\")) return resolve(homedir(), input.slice(2));
+	return input;
 }
 const SOURCE_ALIASES = { "coinbase/agentWallet": "coinbase/agentic-wallet-skills" };
 function buildDefaultGitUrl(repoPath) {
@@ -113,7 +119,7 @@ function parseSource(input) {
 	const alias = SOURCE_ALIASES[input];
 	if (alias) input = alias;
 	if (isLocalPath(input)) {
-		const resolvedPath = resolve(input);
+		const resolvedPath = resolve(expandLocalPath(input));
 		return {
 			type: "local",
 			url: resolvedPath,
@@ -678,6 +684,117 @@ function filterSkills(skills, inputNames) {
 		return normalizedInputs.some((input) => input === name || input === displayName);
 	});
 }
+const execFileAsync = promisify(execFile);
+const GATEWAY_PROCESS_RE = /(?:yonclaw|openclaw)-gateway/i;
+const YONCLAW_PROCESS_RE = /yonclaw|openclaw-gateway|yonclaw-gateway/i;
+function getYonClawBaseDir(options = {}) {
+	if (options.baseDir) return options.baseDir;
+	const home = options.homeDir ?? homedir();
+	const currentPlatform = options.platform ?? platform();
+	const env = options.env ?? process.env;
+	if (currentPlatform === "darwin") return join(home, "Library", "Application Support", "yonclaw");
+	if (currentPlatform === "win32") return join(env.APPDATA || join(home, "AppData", "Roaming"), "yonclaw");
+	return join(options.xdgConfigDir || env.XDG_CONFIG_HOME || xdgConfig || join(home, ".config"), "yonclaw");
+}
+function getYonClawProfileSkillsDir(baseDir, profileKey) {
+	return join(baseDir, "profiles", profileKey, "userData", "runtime", "openclaw", "skills");
+}
+function getYonClawGlobalSkillsDirHint(options = {}) {
+	return getYonClawProfileSkillsDir(getYonClawBaseDir(options), "profile-*");
+}
+async function readJson(path) {
+	try {
+		return JSON.parse(await readFile(path, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+async function listProfileKeys(baseDir) {
+	try {
+		return (await readdir(join(baseDir, "profiles"), { withFileTypes: true })).filter((entry) => entry.isDirectory() && entry.name.startsWith("profile-")).map((entry) => entry.name).sort();
+	} catch {
+		return [];
+	}
+}
+function unique(items) {
+	return Array.from(new Set(items));
+}
+function parseUserDataProfile(command) {
+	const match = command.match(/--user-data-dir=(?:"([^"]+)"|'([^']+)'|(\S+))/);
+	const userDataDir = match?.[1] ?? match?.[2] ?? match?.[3];
+	if (!userDataDir) return null;
+	return normalize(userDataDir).match(/[\\/]profiles[\\/]([^\\/]+)[\\/]userData$/)?.[1] ?? null;
+}
+function isLivePid(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error instanceof Error && "code" in error && error.code === "EPERM";
+	}
+}
+function parsePsOutput(stdout) {
+	return stdout.split("\n").map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+		const match = line.match(/^(\d+)\s+(.+)$/);
+		if (!match) return [];
+		return [{
+			pid: Number(match[1]),
+			command: match[2]
+		}];
+	});
+}
+function parsePowershellProcesses(stdout) {
+	try {
+		const parsed = JSON.parse(stdout);
+		return (Array.isArray(parsed) ? parsed : [parsed]).flatMap((item) => {
+			if (typeof item.ProcessId !== "number" || typeof item.CommandLine !== "string") return [];
+			return [{
+				pid: item.ProcessId,
+				command: item.CommandLine
+			}];
+		});
+	} catch {
+		return [];
+	}
+}
+async function listYonClawProcesses(currentPlatform = platform()) {
+	try {
+		if (currentPlatform === "win32") {
+			const { stdout } = await execFileAsync("powershell.exe", [
+				"-NoProfile",
+				"-Command",
+				"Get-CimInstance Win32_Process | Select-Object ProcessId,CommandLine | ConvertTo-Json -Compress"
+			]);
+			return parsePowershellProcesses(stdout);
+		}
+		const { stdout } = await execFileAsync("ps", ["-axo", "pid=,command="]);
+		return parsePsOutput(stdout);
+	} catch {
+		return [];
+	}
+}
+async function resolveYonClawGlobalSkillsDirs(options = {}) {
+	const baseDir = getYonClawBaseDir(options);
+	const profileKeys = await listProfileKeys(baseDir);
+	if (profileKeys.length === 0) return [];
+	const processes = await (options.processProvider ?? { listProcesses: () => listYonClawProcesses(options.platform) }).listProcesses();
+	const processByPid = new Map(processes.map((processInfo) => [processInfo.pid, processInfo]));
+	const liveGatewayProfiles = [];
+	for (const profileKey of profileKeys) {
+		const runtime = await readJson(join(baseDir, "profiles", profileKey, "userData", "gateway-runtime.json"));
+		if (typeof runtime?.pid !== "number") continue;
+		const processInfo = processByPid.get(runtime.pid);
+		if (processInfo && GATEWAY_PROCESS_RE.test(processInfo.command) && isLivePid(runtime.pid)) liveGatewayProfiles.push(profileKey);
+	}
+	if (liveGatewayProfiles.length > 0) return unique(liveGatewayProfiles).map((profileKey) => getYonClawProfileSkillsDir(baseDir, profileKey));
+	const userDataProfiles = unique(processes.filter((processInfo) => YONCLAW_PROCESS_RE.test(processInfo.command)).map((processInfo) => parseUserDataProfile(processInfo.command)).filter((profileKey) => Boolean(profileKey)).filter((profileKey) => profileKeys.includes(profileKey)));
+	if (userDataProfiles.length > 0) return userDataProfiles.map((profileKey) => getYonClawProfileSkillsDir(baseDir, profileKey));
+	if (processes.some((processInfo) => YONCLAW_PROCESS_RE.test(processInfo.command))) {
+		const activeProfile = await readJson(join(baseDir, "device", "active-profile.json"));
+		if (typeof activeProfile?.profileKey === "string" && profileKeys.includes(activeProfile.profileKey)) return [getYonClawProfileSkillsDir(baseDir, activeProfile.profileKey)];
+	}
+	return profileKeys.map((profileKey) => getYonClawProfileSkillsDir(baseDir, profileKey));
+}
 const home = homedir();
 const configHome = xdgConfig ?? join(home, ".config");
 const codexHome = process.env.CODEX_HOME?.trim() || join(home, ".codex");
@@ -698,6 +815,17 @@ const agents = {
 			return existsSync(join(configHome, "amp"));
 		}
 	},
+	yonclaw: {
+		name: "yonclaw",
+		displayName: "YonClaw",
+		skillsDir: "runtime/openclaw/skills",
+		globalSkillsDir: getYonClawGlobalSkillsDirHint(),
+		resolveGlobalSkillsDirs: resolveYonClawGlobalSkillsDirs,
+		supportsProjectInstall: false,
+		detectInstalled: async () => {
+			return existsSync(getYonClawBaseDir());
+		}
+	},
 	antigravity: {
 		name: "antigravity",
 		displayName: "Antigravity",
@@ -1074,6 +1202,10 @@ function getNonUniversalAgents() {
 function isUniversalAgent(type) {
 	return agents[type].skillsDir === ".agents/skills";
 }
+function agentSupportsGlobalInstall$1(agentType) {
+	const agent = agents[agentType];
+	return agent.globalSkillsDir !== void 0 || agent.resolveGlobalSkillsDirs !== void 0;
+}
 function sanitizeName(name) {
 	return name.toLowerCase().replace(/[^a-z0-9._]+/g, "-").replace(/^[.\-]+|[.\-]+$/g, "").substring(0, 255) || "unnamed-skill";
 }
@@ -1095,6 +1227,13 @@ function getAgentBaseDir(agentType, global, cwd) {
 	}
 	return join(baseDir, agent.skillsDir);
 }
+async function getAgentBaseDirs(agentType, global, cwd) {
+	const agent = agents[agentType];
+	if (!global && agent.supportsProjectInstall === false) return [];
+	if (global && agent.resolveGlobalSkillsDirs) return agent.resolveGlobalSkillsDirs();
+	if (global && !agentSupportsGlobalInstall$1(agentType)) return [];
+	return [getAgentBaseDir(agentType, global, cwd)];
+}
 function resolveSymlinkTarget(linkPath, linkTarget) {
 	return resolve(dirname(linkPath), linkTarget);
 }
@@ -1146,7 +1285,13 @@ async function installSkillForAgent(skill, agentType, options = {}) {
 	const agent = agents[agentType];
 	const isGlobal = options.global ?? false;
 	const cwd = options.cwd || process.cwd();
-	if (isGlobal && agent.globalSkillsDir === void 0) return {
+	if (!isGlobal && agent.supportsProjectInstall === false) return {
+		success: false,
+		path: "",
+		mode: options.mode ?? "symlink",
+		error: `${agent.displayName} only supports global skill installation. Use --global.`
+	};
+	if (isGlobal && !agentSupportsGlobalInstall$1(agentType)) return {
 		success: false,
 		path: "",
 		mode: options.mode ?? "symlink",
@@ -1155,28 +1300,37 @@ async function installSkillForAgent(skill, agentType, options = {}) {
 	const skillName = sanitizeName(skill.name || basename(skill.path));
 	const canonicalBase = getCanonicalSkillsDir(isGlobal, cwd);
 	const canonicalDir = join(canonicalBase, skillName);
-	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd);
-	const agentDir = join(agentBase, skillName);
+	const agentBases = await getAgentBaseDirs(agentType, isGlobal, cwd);
+	const agentDirs = agentBases.map((agentBase) => join(agentBase, skillName));
+	const agentDir = agentDirs[0] ?? "";
 	const installMode = options.mode ?? "symlink";
+	if (agentBases.length === 0) return {
+		success: false,
+		path: "",
+		mode: installMode,
+		error: `No ${agent.displayName} skills directories found`
+	};
 	if (!isPathSafe(canonicalBase, canonicalDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
-	if (!isPathSafe(agentBase, agentDir)) return {
+	for (const [index, agentBase] of agentBases.entries()) if (!isPathSafe(agentBase, agentDirs[index])) return {
 		success: false,
-		path: agentDir,
+		path: agentDirs[index],
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
 	try {
 		if (installMode === "copy") {
-			await cleanAndCreateDirectory(agentDir);
-			await copyDirectory(skill.path, agentDir);
+			await Promise.all(agentDirs.map(async (targetDir) => {
+				await cleanAndCreateDirectory(targetDir);
+				await copyDirectory(skill.path, targetDir);
+			}));
 			return {
 				success: true,
-				path: agentDir,
+				path: agentDirs.join(", "),
 				mode: "copy"
 			};
 		}
@@ -1188,22 +1342,18 @@ async function installSkillForAgent(skill, agentType, options = {}) {
 			canonicalPath: canonicalDir,
 			mode: "symlink"
 		};
-		if (!await createSymlink(canonicalDir, agentDir)) {
-			await cleanAndCreateDirectory(agentDir);
-			await copyDirectory(skill.path, agentDir);
-			return {
-				success: true,
-				path: agentDir,
-				canonicalPath: canonicalDir,
-				mode: "symlink",
-				symlinkFailed: true
-			};
+		let symlinkFailed = false;
+		for (const targetDir of agentDirs) if (!await createSymlink(canonicalDir, targetDir)) {
+			symlinkFailed = true;
+			await cleanAndCreateDirectory(targetDir);
+			await copyDirectory(skill.path, targetDir);
 		}
 		return {
 			success: true,
-			path: agentDir,
+			path: agentDirs.join(", "),
 			canonicalPath: canonicalDir,
-			mode: "symlink"
+			mode: "symlink",
+			...symlinkFailed && { symlinkFailed: true }
 		};
 	} catch (error) {
 		return {
@@ -1238,25 +1388,27 @@ async function copyDirectory(src, dest) {
 async function isSkillInstalled(skillName, agentType, options = {}) {
 	const agent = agents[agentType];
 	const sanitized = sanitizeName(skillName);
-	if (options.global && agent.globalSkillsDir === void 0) return false;
-	const targetBase = options.global ? agent.globalSkillsDir : join(options.cwd || process.cwd(), agent.skillsDir);
-	const skillDir = join(targetBase, sanitized);
-	if (!isPathSafe(targetBase, skillDir)) return false;
-	try {
-		await access(skillDir);
-		return true;
-	} catch {
-		return false;
+	if (!options.global && agent.supportsProjectInstall === false) return false;
+	if (options.global && !agentSupportsGlobalInstall$1(agentType)) return false;
+	const targetBases = await getAgentBaseDirs(agentType, options.global ?? false, options.cwd);
+	if (targetBases.length === 0) return false;
+	for (const targetBase of targetBases) {
+		const skillDir = join(targetBase, sanitized);
+		if (!isPathSafe(targetBase, skillDir)) continue;
+		try {
+			await access(skillDir);
+			return true;
+		} catch {}
 	}
+	return false;
 }
-function getInstallPath(skillName, agentType, options = {}) {
-	agents[agentType];
-	options.cwd || process.cwd();
+async function getInstallPaths(skillName, agentType, options = {}) {
 	const sanitized = sanitizeName(skillName);
-	const targetBase = getAgentBaseDir(agentType, options.global ?? false, options.cwd);
-	const installPath = join(targetBase, sanitized);
-	if (!isPathSafe(targetBase, installPath)) throw new Error("Invalid skill name: potential path traversal detected");
-	return installPath;
+	return (await getAgentBaseDirs(agentType, options.global ?? false, options.cwd)).map((targetBase) => {
+		const installPath = join(targetBase, sanitized);
+		if (!isPathSafe(targetBase, installPath)) throw new Error("Invalid skill name: potential path traversal detected");
+		return installPath;
+	});
 }
 function getCanonicalPath(skillName, options = {}) {
 	const sanitized = sanitizeName(skillName);
@@ -1270,7 +1422,13 @@ async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
 	const isGlobal = options.global ?? false;
 	const cwd = options.cwd || process.cwd();
 	const installMode = options.mode ?? "symlink";
-	if (isGlobal && agent.globalSkillsDir === void 0) return {
+	if (!isGlobal && agent.supportsProjectInstall === false) return {
+		success: false,
+		path: "",
+		mode: installMode,
+		error: `${agent.displayName} only supports global skill installation. Use --global.`
+	};
+	if (isGlobal && !agentSupportsGlobalInstall$1(agentType)) return {
 		success: false,
 		path: "",
 		mode: installMode,
@@ -1279,17 +1437,24 @@ async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
 	const skillName = sanitizeName(skill.installName);
 	const canonicalBase = getCanonicalSkillsDir(isGlobal, cwd);
 	const canonicalDir = join(canonicalBase, skillName);
-	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd);
-	const agentDir = join(agentBase, skillName);
+	const agentBases = await getAgentBaseDirs(agentType, isGlobal, cwd);
+	const agentDirs = agentBases.map((agentBase) => join(agentBase, skillName));
+	const agentDir = agentDirs[0] ?? "";
+	if (agentBases.length === 0) return {
+		success: false,
+		path: "",
+		mode: installMode,
+		error: `No ${agent.displayName} skills directories found`
+	};
 	if (!isPathSafe(canonicalBase, canonicalDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
-	if (!isPathSafe(agentBase, agentDir)) return {
+	for (const [index, agentBase] of agentBases.entries()) if (!isPathSafe(agentBase, agentDirs[index])) return {
 		success: false,
-		path: agentDir,
+		path: agentDirs[index],
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
@@ -1304,11 +1469,13 @@ async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
 	}
 	try {
 		if (installMode === "copy") {
-			await cleanAndCreateDirectory(agentDir);
-			await writeSkillFiles(agentDir);
+			await Promise.all(agentDirs.map(async (targetDir) => {
+				await cleanAndCreateDirectory(targetDir);
+				await writeSkillFiles(targetDir);
+			}));
 			return {
 				success: true,
-				path: agentDir,
+				path: agentDirs.join(", "),
 				mode: "copy"
 			};
 		}
@@ -1320,22 +1487,18 @@ async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
 			canonicalPath: canonicalDir,
 			mode: "symlink"
 		};
-		if (!await createSymlink(canonicalDir, agentDir)) {
-			await cleanAndCreateDirectory(agentDir);
-			await writeSkillFiles(agentDir);
-			return {
-				success: true,
-				path: agentDir,
-				canonicalPath: canonicalDir,
-				mode: "symlink",
-				symlinkFailed: true
-			};
+		let symlinkFailed = false;
+		for (const targetDir of agentDirs) if (!await createSymlink(canonicalDir, targetDir)) {
+			symlinkFailed = true;
+			await cleanAndCreateDirectory(targetDir);
+			await writeSkillFiles(targetDir);
 		}
 		return {
 			success: true,
-			path: agentDir,
+			path: agentDirs.join(", "),
 			canonicalPath: canonicalDir,
-			mode: "symlink"
+			mode: "symlink",
+			...symlinkFailed && { symlinkFailed: true }
 		};
 	} catch (error) {
 		return {
@@ -1362,10 +1525,10 @@ async function listInstalledSkills(options = {}) {
 			path: getCanonicalSkillsDir(isGlobal, cwd)
 		});
 		for (const agentType of agentsToCheck) {
-			const agent = agents[agentType];
-			if (isGlobal && agent.globalSkillsDir === void 0) continue;
-			const agentDir = isGlobal ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
-			if (!scopes.some((s) => s.path === agentDir && s.global === isGlobal)) scopes.push({
+			agents[agentType];
+			if (isGlobal && !agentSupportsGlobalInstall$1(agentType)) continue;
+			const agentDirs = await getAgentBaseDirs(agentType, isGlobal, cwd);
+			for (const agentDir of agentDirs) if (!scopes.some((s) => s.path === agentDir && s.global === isGlobal)) scopes.push({
 				global: isGlobal,
 				path: agentDir,
 				agentType
@@ -1404,41 +1567,47 @@ async function listInstalledSkills(options = {}) {
 			const sanitizedSkillName = sanitizeName(skill.name);
 			const installedAgents = [];
 			for (const agentType of agentsToCheck) {
-				const agent = agents[agentType];
-				if (scope.global && agent.globalSkillsDir === void 0) continue;
-				const agentBase = scope.global ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
+				agents[agentType];
+				if (scope.global && !agentSupportsGlobalInstall$1(agentType)) continue;
 				let found = false;
+				const agentBases = await getAgentBaseDirs(agentType, scope.global, cwd);
 				const possibleNames = Array.from(new Set([
 					entry.name,
 					sanitizedSkillName,
 					skill.name.toLowerCase().replace(/\s+/g, "-").replace(/[\/\\:\0]/g, "")
 				]));
-				for (const possibleName of possibleNames) {
-					const agentSkillDir = join(agentBase, possibleName);
-					if (!isPathSafe(agentBase, agentSkillDir)) continue;
-					try {
-						await access(agentSkillDir);
-						found = true;
-						break;
-					} catch {}
-				}
-				if (!found) try {
-					const agentEntries = await readdir(agentBase, { withFileTypes: true });
-					for (const agentEntry of agentEntries) {
-						if (!agentEntry.isDirectory()) continue;
-						const candidateDir = join(agentBase, agentEntry.name);
-						if (!isPathSafe(agentBase, candidateDir)) continue;
+				for (const agentBase of agentBases) {
+					for (const possibleName of possibleNames) {
+						const agentSkillDir = join(agentBase, possibleName);
+						if (!isPathSafe(agentBase, agentSkillDir)) continue;
 						try {
-							const candidateSkillMd = join(candidateDir, "SKILL.md");
-							await stat(candidateSkillMd);
-							const candidateSkill = await parseSkillMd(candidateSkillMd);
-							if (candidateSkill && candidateSkill.name === skill.name) {
-								found = true;
-								break;
-							}
+							await access(agentSkillDir);
+							found = true;
+							break;
 						} catch {}
 					}
-				} catch {}
+					if (found) break;
+				}
+				if (!found) for (const agentBase of agentBases) {
+					try {
+						const agentEntries = await readdir(agentBase, { withFileTypes: true });
+						for (const agentEntry of agentEntries) {
+							if (!agentEntry.isDirectory()) continue;
+							const candidateDir = join(agentBase, agentEntry.name);
+							if (!isPathSafe(agentBase, candidateDir)) continue;
+							try {
+								const candidateSkillMd = join(candidateDir, "SKILL.md");
+								await stat(candidateSkillMd);
+								const candidateSkill = await parseSkillMd(candidateSkillMd);
+								if (candidateSkill && candidateSkill.name === skill.name) {
+									found = true;
+									break;
+								}
+							} catch {}
+						}
+					} catch {}
+					if (found) break;
+				}
 				if (found) installedAgents.push(agentType);
 			}
 			if (skillsMap.has(skillKey)) {
@@ -2070,7 +2239,7 @@ function createEmptyLocalLock() {
 		skills: {}
 	};
 }
-var version$1 = "1.4.10";
+var version$1 = "1.4.12";
 const isCancelled$1 = (value) => typeof value === "symbol";
 async function isSourcePrivate(source) {
 	const ownerRepo = parseOwnerRepo(source);
@@ -2208,6 +2377,31 @@ function ensureUniversalAgents(targetAgents) {
 	for (const ua of universalAgents) if (!result.includes(ua)) result.push(ua);
 	return result;
 }
+function agentSupportsGlobalInstall(agent) {
+	return agents[agent].globalSkillsDir !== void 0 || agents[agent].resolveGlobalSkillsDirs !== void 0;
+}
+function agentSupportsScope(agent, global) {
+	if (global === true) return agentSupportsGlobalInstall(agent);
+	if (global === false) return agents[agent].supportsProjectInstall !== false;
+	return true;
+}
+function filterProjectUnsupportedAgents(targetAgents, installGlobally, explicitlyRequestedAgents) {
+	if (installGlobally) return targetAgents;
+	const unsupported = targetAgents.filter((agent) => agents[agent].supportsProjectInstall === false);
+	if (unsupported.length === 0) return targetAgents;
+	const explicitUnsupported = explicitlyRequestedAgents?.filter((agent) => agent !== "*" && unsupported.includes(agent));
+	if (explicitUnsupported && explicitUnsupported.length > 0) {
+		M.error(`${formatList$1(unsupported.map((agent) => agents[agent].displayName))} only supports global skill installation. Use --global.`);
+		process.exit(1);
+	}
+	M.warn(`Skipping ${formatList$1(unsupported.map((agent) => agents[agent].displayName))}: global-only agent`);
+	const filtered = targetAgents.filter((agent) => agents[agent].supportsProjectInstall !== false);
+	if (filtered.length === 0) {
+		M.error("No selected agents support project skill installation.");
+		process.exit(1);
+	}
+	return filtered;
+}
 function buildResultLines(results, targetAgents) {
 	const lines = [];
 	const { universal, symlinked: symlinkAgents } = splitAgentsByType(targetAgents);
@@ -2251,9 +2445,9 @@ async function promptForAgents(message, choices) {
 	return selected;
 }
 async function selectAgentsInteractive(options) {
-	const supportsGlobalFilter = (a) => !options.global || agents[a].globalSkillsDir;
-	const universalAgents = getUniversalAgents().filter(supportsGlobalFilter);
-	const otherAgents = getNonUniversalAgents().filter(supportsGlobalFilter);
+	const supportsScopeFilter = (a) => agentSupportsScope(a, options.global);
+	const universalAgents = getUniversalAgents().filter(supportsScopeFilter);
+	const otherAgents = getNonUniversalAgents().filter(supportsScopeFilter);
 	const universalSection = {
 		title: "Universal (.agents/skills)",
 		items: universalAgents.map((a) => ({
@@ -2312,8 +2506,11 @@ function reportInstallToSunIfNeeded(params) {
 function isBareSkillNameSource(source) {
 	return /^[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?$/.test(source);
 }
+function isFilesystemPathLike(source) {
+	return isAbsolute(source) || source === "~" || source.startsWith("~/") || source.startsWith("~\\") || source.startsWith("./") || source.startsWith("../") || source === "." || source === ".." || /^[a-zA-Z]:[/\\]/.test(source);
+}
 function shouldProbeDefaultWellKnownPath(source) {
-	return source.includes("/") && !source.includes("@") && !source.startsWith("http://") && !source.startsWith("https://") && !source.startsWith("git@") && !source.startsWith("ssh://") && !source.startsWith("./") && !source.startsWith("../") && source !== "." && source !== "..";
+	return source.includes("/") && !source.includes("@") && !source.startsWith("http://") && !source.startsWith("https://") && !source.startsWith("git@") && !source.startsWith("ssh://") && !isFilesystemPathLike(source);
 }
 function buildFallbackGitSshUrl(source) {
 	return `git@${DEFAULT_GIT_FALLBACK_SSH_HOST}:${source.replace(/\.git$/, "")}.git`;
@@ -2441,7 +2638,7 @@ async function handleWellKnownSkills(source, url, options, spinner, allowFallbac
 			}
 		}
 		let installGlobally = options.global ?? false;
-		const supportsGlobal = targetAgents.some((a) => agents[a].globalSkillsDir !== void 0);
+		const supportsGlobal = targetAgents.some(agentSupportsGlobalInstall);
 		if (options.global === void 0 && !options.yes && supportsGlobal) {
 			const scope = await ve({
 				message: "Installation scope",
@@ -2461,6 +2658,7 @@ async function handleWellKnownSkills(source, url, options, spinner, allowFallbac
 			}
 			installGlobally = scope;
 		}
+		targetAgents = filterProjectUnsupportedAgents(targetAgents, installGlobally, options.agent);
 		let installMode = options.copy ? "copy" : "symlink";
 		if (!options.copy && !options.yes) {
 			const modeChoice = await ve({
@@ -2900,7 +3098,7 @@ async function runAdd(args, options = {}) {
 			}
 		}
 		let installGlobally = options.global ?? false;
-		const supportsGlobal = targetAgents.some((a) => agents[a].globalSkillsDir !== void 0);
+		const supportsGlobal = targetAgents.some(agentSupportsGlobalInstall);
 		if (options.global === void 0 && !options.yes && supportsGlobal) {
 			const scope = await ve({
 				message: "Installation scope",
@@ -2921,6 +3119,7 @@ async function runAdd(args, options = {}) {
 			}
 			installGlobally = scope;
 		}
+		targetAgents = filterProjectUnsupportedAgents(targetAgents, installGlobally, options.agent);
 		let installMode = options.copy ? "copy" : "symlink";
 		if (!options.copy && !options.yes) {
 			const modeChoice = await ve({
@@ -3611,9 +3810,10 @@ async function runSync(args, options = {}) {
 	M.info(`${toInstall.length} skill${toInstall.length !== 1 ? "s" : ""} to install/update`);
 	let targetAgents;
 	const validAgents = Object.keys(agents);
+	const projectAgents = validAgents.filter((agent) => agents[agent].supportsProjectInstall !== false);
 	const universalAgents = getUniversalAgents();
 	if (options.agent?.includes("*")) {
-		targetAgents = validAgents;
+		targetAgents = projectAgents;
 		M.info(`Installing to all ${targetAgents.length} agents`);
 	} else if (options.agent && options.agent.length > 0) {
 		const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
@@ -3622,7 +3822,11 @@ async function runSync(args, options = {}) {
 			M.info(`Valid agents: ${validAgents.join(", ")}`);
 			process.exit(1);
 		}
-		targetAgents = options.agent;
+		targetAgents = options.agent.filter((agent) => {
+			if (agents[agent].supportsProjectInstall !== false) return true;
+			M.error(`${agents[agent].displayName} only supports global skill installation.`);
+			process.exit(1);
+		});
 	} else {
 		spinner.start("Loading agents...");
 		const installedAgents = await detectInstalledAgents();
@@ -3634,7 +3838,7 @@ async function runSync(args, options = {}) {
 		} else {
 			const selected = await searchMultiselect({
 				message: "Which agents do you want to install to?",
-				items: getNonUniversalAgents().map((a) => ({
+				items: getNonUniversalAgents().filter((agent) => agents[agent].supportsProjectInstall !== false).map((a) => ({
 					value: a,
 					label: agents[a].displayName,
 					hint: agents[a].skillsDir
@@ -3655,12 +3859,12 @@ async function runSync(args, options = {}) {
 			targetAgents = selected;
 		}
 		else if (installedAgents.length === 1 || options.yes) {
-			targetAgents = [...installedAgents];
+			targetAgents = installedAgents.filter((agent) => agents[agent].supportsProjectInstall !== false);
 			for (const ua of universalAgents) if (!targetAgents.includes(ua)) targetAgents.push(ua);
 		} else {
 			const selected = await searchMultiselect({
 				message: "Which agents do you want to install to?",
-				items: getNonUniversalAgents().filter((a) => installedAgents.includes(a)).map((a) => ({
+				items: getNonUniversalAgents().filter((a) => installedAgents.includes(a) && agents[a].supportsProjectInstall !== false).map((a) => ({
 					value: a,
 					label: agents[a].displayName,
 					hint: agents[a].skillsDir
@@ -3941,10 +4145,13 @@ async function removeCommand(skillNames, options) {
 	};
 	if (isGlobal) {
 		await scanDir(getCanonicalSkillsDir(true, cwd));
-		for (const agent of Object.values(agents)) if (agent.globalSkillsDir !== void 0) await scanDir(agent.globalSkillsDir);
+		for (const agentType of Object.keys(agents)) {
+			const agent = agents[agentType];
+			if (agent.globalSkillsDir !== void 0 || agent.resolveGlobalSkillsDirs !== void 0) for (const agentDir of await getAgentBaseDirs(agentType, true, cwd)) await scanDir(agentDir);
+		}
 	} else {
 		await scanDir(getCanonicalSkillsDir(false, cwd));
-		for (const agent of Object.values(agents)) await scanDir(join(cwd, agent.skillsDir));
+		for (const agent of Object.values(agents).filter((agent) => agent.supportsProjectInstall !== false)) await scanDir(join(cwd, agent.skillsDir));
 	}
 	const installedSkills = Array.from(skillNamesSet).sort();
 	spinner.stop(`Found ${installedSkills.length} unique installed skill(s)`);
@@ -4011,14 +4218,16 @@ async function removeCommand(skillNames, options) {
 		});
 		for (const agentKey of targetAgents) {
 			const agent = agents[agentKey];
-			const skillPath = getInstallPath(skillName, agentKey, {
+			const skillPaths = await getInstallPaths(skillName, agentKey, {
 				global: isGlobal,
 				cwd
 			});
-			const pathsToCleanup = new Set([skillPath]);
+			const pathsToCleanup = new Set(skillPaths);
 			const sanitizedName = sanitizeName(skillName);
-			if (isGlobal && agent.globalSkillsDir) pathsToCleanup.add(join(agent.globalSkillsDir, sanitizedName));
-			else pathsToCleanup.add(join(cwd, agent.skillsDir, sanitizedName));
+			if (isGlobal) {
+				const globalDirs = await getAgentBaseDirs(agentKey, true, cwd);
+				for (const globalDir of globalDirs) pathsToCleanup.add(join(globalDir, sanitizedName));
+			} else if (agent.supportsProjectInstall !== false) pathsToCleanup.add(join(cwd, agent.skillsDir, sanitizedName));
 			for (const pathToCleanup of pathsToCleanup) {
 				if (pathToCleanup === canonicalPath) continue;
 				try {
@@ -4033,12 +4242,16 @@ async function removeCommand(skillNames, options) {
 		}
 		const remainingAgents = (await detectInstalledAgents()).filter((a) => !targetAgents.includes(a));
 		let isStillUsed = false;
-		for (const agentKey of remainingAgents) if (await lstat(getInstallPath(skillName, agentKey, {
-			global: isGlobal,
-			cwd
-		})).catch(() => null)) {
-			isStillUsed = true;
-			break;
+		for (const agentKey of remainingAgents) {
+			const paths = await getInstallPaths(skillName, agentKey, {
+				global: isGlobal,
+				cwd
+			});
+			for (const path of paths) if (await lstat(path).catch(() => null)) {
+				isStillUsed = true;
+				break;
+			}
+			if (isStillUsed) break;
 		}
 		if (!isStillUsed) await rm(canonicalPath, {
 			recursive: true,

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "bip-skills",
-  "version": "1.4.10",
+  "version": "1.4.12",
   "description": "The open agent skills ecosystem",
   "type": "module",
   "bin": {
-    "bip-skills": "./bin/cli.mjs",
-    "skills": "./bin/cli.mjs",
-    "add-skill": "./bin/cli.mjs"
+    "bip-skills": "bin/cli.mjs",
+    "skills": "bin/cli.mjs",
+    "add-skill": "bin/cli.mjs"
   },
   "files": [
     "dist",
@@ -14,6 +14,21 @@
     "README.md",
     "ThirdPartyNoticeText.txt"
   ],
+  "scripts": {
+    "build": "obuild && node scripts/generate-licenses.ts",
+    "generate-licenses": "node scripts/generate-licenses.ts",
+    "dev": "node src/cli.ts",
+    "exec:test": "node scripts/execute-tests.ts",
+    "pack:check": "npm pack --dry-run --ignore-scripts --cache .npm-cache",
+    "prepublishOnly": "npm run build",
+    "publish:npm": "node scripts/publish-npm.ts",
+    "format": "prettier --write 'src/**/*.ts' 'scripts/**/*.ts'",
+    "format:check": "prettier --check 'src/**/*.ts' 'scripts/**/*.ts'",
+    "prepare": "husky",
+    "test": "vitest",
+    "type-check": "tsc --noEmit",
+    "publish:snapshot": "npm version prerelease --preid=snapshot --no-git-tag-version && npm publish --tag snapshot"
+  },
   "lint-staged": {
     "src/**/*.ts": "prettier --write",
     "scripts/**/*.ts": "prettier --write",
@@ -29,6 +44,7 @@
     "augment",
     "claude-code",
     "openclaw",
+    "yonclaw",
     "cline",
     "codebuddy",
     "codex",
@@ -95,16 +111,5 @@
   "engines": {
     "node": ">=18"
   },
-  "scripts": {
-    "build": "obuild && node scripts/generate-licenses.ts",
-    "generate-licenses": "node scripts/generate-licenses.ts",
-    "dev": "node src/cli.ts",
-    "exec:test": "node scripts/execute-tests.ts",
-    "pack:check": "npm pack --dry-run --ignore-scripts --cache .npm-cache",
-    "format": "prettier --write 'src/**/*.ts' 'scripts/**/*.ts'",
-    "format:check": "prettier --check 'src/**/*.ts' 'scripts/**/*.ts'",
-    "test": "vitest",
-    "type-check": "tsc --noEmit",
-    "publish:snapshot": "npm version prerelease --preid=snapshot --no-git-tag-version && npm publish --tag snapshot"
-  }
-}
+  "packageManager": "pnpm@10.17.1"
+}