skill-atlas-cli 0.1.4

package/lib/index.js

@@ -0,0 +1,1128 @@
+import fs, { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path, { join } from "node:path";
+import os, { homedir } from "node:os";
+import semver from "semver";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import path$1, { basename, dirname, join as join$1, normalize, relative, resolve, sep } from "path";
+import { existsSync as existsSync$1, writeFileSync as writeFileSync$1 } from "fs";
+import os$1, { homedir as homedir$1, platform, tmpdir } from "os";
+import * as readline from "readline";
+import { Writable } from "stream";
+import { cp, lstat, mkdir, readdir, readlink, realpath, rename, rm, stat, symlink, unlink, writeFile } from "fs/promises";
+import { execSync } from "child_process";
+import { info } from "console";
+import { createConsola } from "consola";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region src/core/update-notifier.ts
+/**
+* npm 包更新检查：有新版本时提示无需重装，直接 npm update 即可
+*/
+const CACHE_DIR = process.env.XDG_CONFIG_HOME || join(homedir(), ".config", "skill-atlas");
+const CACHE_FILE = join(CACHE_DIR, "update-check.json");
+const CHECK_INTERVAL = 1e3 * 60 * 60 * 24;
+async function fetchLatestVersion(pkgName) {
+	return (await (await fetch(`https://registry.npmjs.org/-/package/${pkgName}/dist-tags`)).json()).latest || "0.0.0";
+}
+function getLastCheck() {
+	try {
+		if (!existsSync(CACHE_FILE)) return void 0;
+		return JSON.parse(readFileSync(CACHE_FILE, "utf8")).lastCheck;
+	} catch {
+		return;
+	}
+}
+function saveLastCheck() {
+	try {
+		if (!existsSync(CACHE_DIR)) mkdirSync(CACHE_DIR, { recursive: true });
+		writeFileSync(CACHE_FILE, JSON.stringify({ lastCheck: Date.now() }) + "\n");
+	} catch {}
+}
+/**
+* 检查更新，有新版本时输出提示（无需重装，直接 update）
+*/
+function checkForUpdate(pkg) {
+	if (!process.stdout.isTTY) return;
+	const lastCheck = getLastCheck();
+	if (lastCheck && Date.now() - lastCheck < CHECK_INTERVAL) return;
+	fetchLatestVersion(pkg.name).then((latest) => {
+		saveLastCheck();
+		if (semver.gt(latest, pkg.version)) console.error(`\n  Update available: ${pkg.version} → ${latest}\n  No need to reinstall. Run: npm update -g ${pkg.name}\n`);
+	}).catch(() => {});
+}
+//#endregion
+//#region src/core/config.ts
+var import_picocolors = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string = "" + input, index = string.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+	};
+	let replaceClose = (string, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string.indexOf(close, cursor);
+		} while (~index);
+		return result + string.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1B[0m", "\x1B[0m"),
+			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f("\x1B[3m", "\x1B[23m"),
+			underline: f("\x1B[4m", "\x1B[24m"),
+			inverse: f("\x1B[7m", "\x1B[27m"),
+			hidden: f("\x1B[8m", "\x1B[28m"),
+			strikethrough: f("\x1B[9m", "\x1B[29m"),
+			black: f("\x1B[30m", "\x1B[39m"),
+			red: f("\x1B[31m", "\x1B[39m"),
+			green: f("\x1B[32m", "\x1B[39m"),
+			yellow: f("\x1B[33m", "\x1B[39m"),
+			blue: f("\x1B[34m", "\x1B[39m"),
+			magenta: f("\x1B[35m", "\x1B[39m"),
+			cyan: f("\x1B[36m", "\x1B[39m"),
+			white: f("\x1B[37m", "\x1B[39m"),
+			gray: f("\x1B[90m", "\x1B[39m"),
+			bgBlack: f("\x1B[40m", "\x1B[49m"),
+			bgRed: f("\x1B[41m", "\x1B[49m"),
+			bgGreen: f("\x1B[42m", "\x1B[49m"),
+			bgYellow: f("\x1B[43m", "\x1B[49m"),
+			bgBlue: f("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f("\x1B[45m", "\x1B[49m"),
+			bgCyan: f("\x1B[46m", "\x1B[49m"),
+			bgWhite: f("\x1B[47m", "\x1B[49m"),
+			blackBright: f("\x1B[90m", "\x1B[39m"),
+			redBright: f("\x1B[91m", "\x1B[39m"),
+			greenBright: f("\x1B[92m", "\x1B[39m"),
+			yellowBright: f("\x1B[93m", "\x1B[39m"),
+			blueBright: f("\x1B[94m", "\x1B[39m"),
+			magentaBright: f("\x1B[95m", "\x1B[39m"),
+			cyanBright: f("\x1B[96m", "\x1B[39m"),
+			whiteBright: f("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+		};
+	};
+	module.exports = createColors();
+	module.exports.createColors = createColors;
+})))(), 1);
+const CONFIG_DIR = path.join(os.homedir(), ".openclawmp");
+const AUTH_FILE = path.join(CONFIG_DIR, "auth.json");
+const CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials.json");
+let API_BASE = "https://pre-skillhub.aliyun-inc.com";
+const OPENCLAW_STATE_DIR = process.env.OPENCLAW_STATE_DIR || path.join(os.homedir(), ".openclaw");
+const LOCKFILE = path.join(OPENCLAW_STATE_DIR, "seafood-lock.json");
+const DEVICE_JSON = path.join(OPENCLAW_STATE_DIR, "identity", "device.json");
+const ASSET_TYPES = {
+	skill: "skills",
+	plugin: "plugins",
+	trigger: "triggers",
+	channel: "channels",
+	experience: "experiences"
+};
+/**
+* Ensure config directory exists
+*/
+function ensureConfigDir() {
+	if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+/**
+* Get the install directory for a given asset type
+*/
+function installDirForType(type) {
+	const subdir = ASSET_TYPES[type];
+	if (!subdir) throw new Error(`Unknown asset type: ${type}. Valid types: ${Object.keys(ASSET_TYPES).join(", ")}`);
+	return path.join(OPENCLAW_STATE_DIR, subdir);
+}
+/**
+* Get/set API base URL
+*/
+function getApiBase() {
+	return API_BASE;
+}
+function setApiBase(url) {
+	API_BASE = url.replace(/\/+$/, "");
+}
+/**
+* Read auth token (priority: env var > auth.json > credentials.json)
+*/
+function getAuthToken() {
+	if (process.env.OPENCLAWMP_TOKEN) return process.env.OPENCLAWMP_TOKEN;
+	ensureConfigDir();
+	if (fs.existsSync(AUTH_FILE)) try {
+		const data = JSON.parse(fs.readFileSync(AUTH_FILE, "utf-8"));
+		if (data.token) return data.token;
+	} catch {}
+	if (fs.existsSync(CREDENTIALS_FILE)) try {
+		const data = JSON.parse(fs.readFileSync(CREDENTIALS_FILE, "utf-8"));
+		if (data.api_key) return data.api_key;
+	} catch {}
+	return null;
+}
+/**
+* Save auth token
+*/
+function saveAuthToken(token, extra = {}) {
+	ensureConfigDir();
+	const data = {
+		token,
+		savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		...extra
+	};
+	fs.writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2) + "\n");
+}
+/**
+* Read the OpenClaw device ID
+*/
+function getDeviceId() {
+	if (!fs.existsSync(DEVICE_JSON)) return null;
+	try {
+		return JSON.parse(fs.readFileSync(DEVICE_JSON, "utf-8")).deviceId || null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Initialize lockfile if it doesn't exist
+*/
+function initLockfile() {
+	if (!fs.existsSync(LOCKFILE)) {
+		const dir = path.dirname(LOCKFILE);
+		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+		fs.writeFileSync(LOCKFILE, JSON.stringify({
+			version: 1,
+			installed: {}
+		}, null, 2) + "\n");
+	}
+}
+/**
+* Read the lockfile
+*/
+function readLockfile() {
+	initLockfile();
+	try {
+		return JSON.parse(fs.readFileSync(LOCKFILE, "utf-8"));
+	} catch {
+		return {
+			version: 1,
+			installed: {}
+		};
+	}
+}
+/**
+* Update a lockfile entry
+*/
+function updateLockfile(key, version, location) {
+	const lock = readLockfile();
+	lock.installed[key] = {
+		version,
+		installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		location
+	};
+	fs.writeFileSync(LOCKFILE, JSON.stringify(lock, null, 2) + "\n");
+}
+/**
+* Remove a lockfile entry
+*/
+function removeLockfile(key) {
+	const lock = readLockfile();
+	delete lock.installed[key];
+	fs.writeFileSync(LOCKFILE, JSON.stringify(lock, null, 2) + "\n");
+}
+var config_default = {
+	CONFIG_DIR,
+	OPENCLAW_STATE_DIR,
+	LOCKFILE,
+	DEVICE_JSON,
+	ASSET_TYPES,
+	ensureConfigDir,
+	installDirForType,
+	getApiBase,
+	setApiBase,
+	getAuthToken,
+	saveAuthToken,
+	getDeviceId,
+	initLockfile,
+	readLockfile,
+	updateLockfile,
+	removeLockfile
+};
+//#endregion
+//#region src/core/api.ts
+/**
+* Make a GET request to the API
+* @param {string} apiPath - API path (e.g., '/api/assets')
+* @param {object} [params] - Query parameters
+* @returns {Promise<object>} Parsed JSON response
+*/
+async function get(apiPath, params = {}) {
+	const url = new URL(apiPath, config_default.getApiBase());
+	for (const [k, v] of Object.entries(params)) if (v !== void 0 && v !== null && v !== "") url.searchParams.set(k, String(v));
+	const res = await fetch(url.toString(), {});
+	if (!res.ok) {
+		const body = await res.text().catch(() => "");
+		throw new Error(`API error ${res.status}: ${body || res.statusText}`);
+	}
+	return res.json();
+}
+function normalizeSearchSkillsResponse(result) {
+	const payload = result && typeof result === "object" && "data" in result ? result.data : result;
+	const normalized = payload && typeof payload === "object" ? payload : {};
+	return {
+		items: Array.isArray(normalized.items) ? normalized.items : [],
+		page: typeof normalized.page === "number" ? normalized.page : 1,
+		pageSize: typeof normalized.pageSize === "number" ? normalized.pageSize : 20,
+		total: typeof normalized.total === "number" ? normalized.total : 0
+	};
+}
+async function searchSkills(params = {}) {
+	return normalizeSearchSkillsResponse(await get("/api/v1/skills", {
+		page: 1,
+		pageSize: 20,
+		...params
+	}));
+}
+async function getSkillDetail(slug) {
+	try {
+		return await get(`/api/v1/skills/${slug}`);
+	} catch (err) {
+		err instanceof Error ? err.message : String(err);
+		return null;
+	}
+}
+async function findAsset(slug) {
+	return await getSkillDetail(slug);
+}
+async function downloadSkillPackage(slug, version) {
+	const url = new URL("/api/v1/download", config_default.getApiBase());
+	url.searchParams.set("slug", slug);
+	url.searchParams.set("version", version);
+	const res = await fetch(url.toString(), {});
+	if (!res.ok) {
+		const body = await res.text().catch(() => "");
+		throw new Error(`下载失败 ${res.status}: ${body || res.statusText}。`);
+	}
+	const arrayBuffer = await res.arrayBuffer();
+	return Buffer.from(arrayBuffer);
+}
+//#endregion
+//#region node_modules/.pnpm/xdg-basedir@5.1.0/node_modules/xdg-basedir/index.js
+const homeDirectory = os$1.homedir();
+const { env } = process;
+const xdgData = env.XDG_DATA_HOME || (homeDirectory ? path$1.join(homeDirectory, ".local", "share") : void 0);
+const xdgConfig = env.XDG_CONFIG_HOME || (homeDirectory ? path$1.join(homeDirectory, ".config") : void 0);
+env.XDG_STATE_HOME || homeDirectory && path$1.join(homeDirectory, ".local", "state");
+env.XDG_CACHE_HOME || homeDirectory && path$1.join(homeDirectory, ".cache");
+env.XDG_RUNTIME_DIR;
+const xdgDataDirectories = (env.XDG_DATA_DIRS || "/usr/local/share/:/usr/share/").split(":");
+if (xdgData) xdgDataDirectories.unshift(xdgData);
+const xdgConfigDirectories = (env.XDG_CONFIG_DIRS || "/etc/xdg").split(":");
+if (xdgConfig) xdgConfigDirectories.unshift(xdgConfig);
+//#endregion
+//#region src/core/agents.ts
+const home = homedir$1();
+const configHome = xdgConfig ?? join$1(home, ".config");
+const codexHome = process.env.CODEX_HOME?.trim() || join$1(home, ".codex");
+const claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join$1(home, ".claude");
+function getOpenClawGlobalSkillsDir(homeDir = home, pathExists = existsSync$1) {
+	if (pathExists(join$1(homeDir, ".openclaw"))) return join$1(homeDir, ".openclaw/skills");
+	if (pathExists(join$1(homeDir, ".clawdbot"))) return join$1(homeDir, ".clawdbot/skills");
+	if (pathExists(join$1(homeDir, ".moltbot"))) return join$1(homeDir, ".moltbot/skills");
+	return join$1(homeDir, ".openclaw/skills");
+}
+const agents = {
+	"claude-code": {
+		name: "claude-code",
+		displayName: "Claude Code",
+		skillsDir: ".claude/skills",
+		globalSkillsDir: join$1(claudeHome, "skills"),
+		detectInstalled: async () => {
+			return existsSync$1(claudeHome);
+		}
+	},
+	openclaw: {
+		name: "openclaw",
+		displayName: "OpenClaw",
+		skillsDir: "skills",
+		globalSkillsDir: getOpenClawGlobalSkillsDir(),
+		detectInstalled: async () => {
+			return existsSync$1(join$1(home, ".openclaw")) || existsSync$1(join$1(home, ".clawdbot")) || existsSync$1(join$1(home, ".moltbot"));
+		}
+	},
+	cline: {
+		name: "cline",
+		displayName: "Cline",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join$1(home, ".agents", "skills"),
+		detectInstalled: async () => {
+			return existsSync$1(join$1(home, ".cline"));
+		}
+	},
+	antigravity: {
+		name: "antigravity",
+		displayName: "Antigravity",
+		skillsDir: ".agent/skills",
+		globalSkillsDir: join$1(home, ".gemini/antigravity/skills"),
+		detectInstalled: async () => {
+			return existsSync$1(join$1(home, ".gemini/antigravity"));
+		}
+	},
+	codex: {
+		name: "codex",
+		displayName: "Codex",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join$1(codexHome, "skills"),
+		detectInstalled: async () => {
+			return existsSync$1(codexHome) || existsSync$1("/etc/codex");
+		}
+	},
+	cursor: {
+		name: "cursor",
+		displayName: "Cursor",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join$1(home, ".cursor/skills"),
+		detectInstalled: async () => {
+			return existsSync$1(join$1(home, ".cursor"));
+		}
+	},
+	"gemini-cli": {
+		name: "gemini-cli",
+		displayName: "Gemini CLI",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join$1(home, ".gemini/skills"),
+		detectInstalled: async () => {
+			return existsSync$1(join$1(home, ".gemini"));
+		}
+	},
+	"github-copilot": {
+		name: "github-copilot",
+		displayName: "GitHub Copilot",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join$1(home, ".copilot/skills"),
+		detectInstalled: async () => {
+			return existsSync$1(join$1(home, ".copilot"));
+		}
+	},
+	"iflow-cli": {
+		name: "iflow-cli",
+		displayName: "iFlow CLI",
+		skillsDir: ".iflow/skills",
+		globalSkillsDir: join$1(home, ".iflow/skills"),
+		detectInstalled: async () => {
+			return existsSync$1(join$1(home, ".iflow"));
+		}
+	},
+	"kimi-cli": {
+		name: "kimi-cli",
+		displayName: "Kimi Code CLI",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join$1(home, ".config/agents/skills"),
+		detectInstalled: async () => {
+			return existsSync$1(join$1(home, ".kimi"));
+		}
+	},
+	"kiro-cli": {
+		name: "kiro-cli",
+		displayName: "Kiro CLI",
+		skillsDir: ".kiro/skills",
+		globalSkillsDir: join$1(home, ".kiro/skills"),
+		detectInstalled: async () => {
+			return existsSync$1(join$1(home, ".kiro"));
+		}
+	},
+	opencode: {
+		name: "opencode",
+		displayName: "OpenCode",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join$1(configHome, "opencode/skills"),
+		detectInstalled: async () => {
+			return existsSync$1(join$1(configHome, "opencode"));
+		}
+	},
+	qoder: {
+		name: "qoder",
+		displayName: "Qoder",
+		skillsDir: ".qoder/skills",
+		globalSkillsDir: join$1(home, ".qoder/skills"),
+		detectInstalled: async () => {
+			return existsSync$1(join$1(home, ".qoder"));
+		}
+	},
+	"qwen-code": {
+		name: "qwen-code",
+		displayName: "Qwen Code",
+		skillsDir: ".qwen/skills",
+		globalSkillsDir: join$1(home, ".qwen/skills"),
+		detectInstalled: async () => {
+			return existsSync$1(join$1(home, ".qwen"));
+		}
+	},
+	trae: {
+		name: "trae",
+		displayName: "Trae",
+		skillsDir: ".trae/skills",
+		globalSkillsDir: join$1(home, ".trae/skills"),
+		detectInstalled: async () => {
+			return existsSync$1(join$1(home, ".trae"));
+		}
+	},
+	"trae-cn": {
+		name: "trae-cn",
+		displayName: "Trae CN",
+		skillsDir: ".trae/skills",
+		globalSkillsDir: join$1(home, ".trae-cn/skills"),
+		detectInstalled: async () => {
+			return existsSync$1(join$1(home, ".trae-cn"));
+		}
+	},
+	universal: {
+		name: "universal",
+		displayName: "Universal",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join$1(configHome, "agents/skills"),
+		showInUniversalList: false,
+		detectInstalled: async () => false
+	}
+};
+//#endregion
+//#region src/core/search-multiselect.ts
+const silentOutput = new Writable({ write(_chunk, _encoding, callback) {
+	callback();
+} });
+const S_STEP_ACTIVE = import_picocolors.default.green("◆");
+const S_STEP_CANCEL = import_picocolors.default.red("■");
+const S_STEP_SUBMIT = import_picocolors.default.green("◇");
+const S_RADIO_ACTIVE = import_picocolors.default.green("●");
+const S_RADIO_INACTIVE = import_picocolors.default.dim("○");
+import_picocolors.default.green("✓");
+const S_BULLET = import_picocolors.default.green("•");
+const S_BAR = import_picocolors.default.dim("│");
+const S_BAR_H = import_picocolors.default.dim("─");
+const cancelSymbol = Symbol("cancel");
+/**
+* Interactive search multiselect prompt.
+* Allows users to filter a long list by typing and select multiple items.
+* Optionally supports a "locked" section that displays always-selected items.
+*/
+async function searchMultiselect(options) {
+	const { message, items, maxVisible = 8, initialSelected = [], required = false, lockedSection, leadingSpacer = 0 } = options;
+	return new Promise((resolve) => {
+		const rl = readline.createInterface({
+			input: process.stdin,
+			output: silentOutput,
+			terminal: !!process.stdin.isTTY
+		});
+		if (process.stdin.isTTY) process.stdin.setRawMode(true);
+		readline.emitKeypressEvents(process.stdin, rl);
+		let query = "";
+		let cursor = 0;
+		const selected = new Set(initialSelected);
+		let lastRenderHeight = 0;
+		const lockedValues = lockedSection ? lockedSection.items.map((i) => i.value) : [];
+		const filter = (item, q) => {
+			if (!q) return true;
+			const lowerQ = q.toLowerCase();
+			return item.label.toLowerCase().includes(lowerQ) || String(item.value).toLowerCase().includes(lowerQ);
+		};
+		const getFiltered = () => {
+			return items.filter((item) => filter(item, query));
+		};
+		const out = process.stderr.isTTY ? process.stderr : process.stdout;
+		const clearRender = () => {
+			if (lastRenderHeight > 0 && out.isTTY) for (let i = 0; i < lastRenderHeight; i++) out.write("\x1B[1A\x1B[2K");
+		};
+		const render = (state = "active") => {
+			clearRender();
+			const lines = [];
+			const filtered = getFiltered();
+			const icon = state === "active" ? S_STEP_ACTIVE : state === "cancel" ? S_STEP_CANCEL : S_STEP_SUBMIT;
+			for (let i = 0; i < leadingSpacer; i++) lines.push(`${S_BAR}`);
+			lines.push(`${icon}  ${import_picocolors.default.bold(message)}`);
+			if (state === "active") {
+				if (lockedSection && lockedSection.items.length > 0) {
+					lines.push(`${S_BAR}`);
+					const lockedTitle = `${import_picocolors.default.bold(lockedSection.title)} ${import_picocolors.default.dim("── always included")}`;
+					lines.push(`${S_BAR}  ${S_BAR_H}${S_BAR_H} ${lockedTitle} ${S_BAR_H.repeat(12)}`);
+					for (const item of lockedSection.items) lines.push(`${S_BAR}    ${S_BULLET} ${import_picocolors.default.bold(item.label)}`);
+					lines.push(`${S_BAR}`);
+					lines.push(`${S_BAR}  ${S_BAR_H}${S_BAR_H} ${import_picocolors.default.bold("Additional agents")} ${S_BAR_H.repeat(29)}`);
+				}
+				const searchLine = `${S_BAR}  ${import_picocolors.default.dim("Search:")} ${query}${import_picocolors.default.inverse(" ")}`;
+				lines.push(searchLine);
+				lines.push(`${S_BAR}  ${import_picocolors.default.dim("↑↓ move, space select, enter confirm")}`);
+				lines.push(`${S_BAR}`);
+				const visibleStart = Math.max(0, Math.min(cursor - Math.floor(maxVisible / 2), filtered.length - maxVisible));
+				const visibleEnd = Math.min(filtered.length, visibleStart + maxVisible);
+				const visibleItems = filtered.slice(visibleStart, visibleEnd);
+				if (filtered.length === 0) lines.push(`${S_BAR}  ${import_picocolors.default.dim("No matches found")}`);
+				else {
+					for (let i = 0; i < visibleItems.length; i++) {
+						const item = visibleItems[i];
+						const actualIndex = visibleStart + i;
+						const isSelected = selected.has(item.value);
+						const isCursor = actualIndex === cursor;
+						const radio = isSelected ? S_RADIO_ACTIVE : S_RADIO_INACTIVE;
+						const label = isCursor ? import_picocolors.default.underline(item.label) : item.label;
+						const hint = item.hint ? import_picocolors.default.dim(` (${item.hint})`) : "";
+						const prefix = isCursor ? import_picocolors.default.cyan("❯") : " ";
+						lines.push(`${S_BAR} ${prefix} ${radio} ${label}${hint}`);
+					}
+					const hiddenBefore = visibleStart;
+					const hiddenAfter = filtered.length - visibleEnd;
+					if (hiddenBefore > 0 || hiddenAfter > 0) {
+						const parts = [];
+						if (hiddenBefore > 0) parts.push(`↑ ${hiddenBefore} more`);
+						if (hiddenAfter > 0) parts.push(`↓ ${hiddenAfter} more`);
+						lines.push(`${S_BAR}  ${import_picocolors.default.dim(parts.join("  "))}`);
+					}
+				}
+				lines.push(`${S_BAR}`);
+				const allSelectedLabels = [...lockedSection ? lockedSection.items.map((i) => i.label) : [], ...items.filter((item) => selected.has(item.value)).map((item) => item.label)];
+				if (allSelectedLabels.length === 0) lines.push(`${S_BAR}  ${import_picocolors.default.dim("Selected: (none)")}`);
+				else {
+					const summary = allSelectedLabels.length <= 3 ? allSelectedLabels.join(", ") : `${allSelectedLabels.slice(0, 3).join(", ")} +${allSelectedLabels.length - 3} more`;
+					lines.push(`${S_BAR}  ${import_picocolors.default.green("Selected:")} ${summary}`);
+				}
+				lines.push(`${import_picocolors.default.dim("└")}`);
+			} else if (state === "submit") {
+				const allSelectedLabels = [...lockedSection ? lockedSection.items.map((i) => i.label) : [], ...items.filter((item) => selected.has(item.value)).map((item) => item.label)];
+				lines.push(`${S_BAR}  ${import_picocolors.default.dim(allSelectedLabels.join(", "))}`);
+			} else if (state === "cancel") lines.push(`${S_BAR}  ${import_picocolors.default.strikethrough(import_picocolors.default.dim("Cancelled"))}`);
+			out.write(lines.join("\n") + "\n");
+			lastRenderHeight = lines.length;
+		};
+		const cleanup = () => {
+			process.stdin.removeListener("keypress", keypressHandler);
+			if (process.stdin.isTTY) process.stdin.setRawMode(false);
+			rl.close();
+		};
+		const submit = () => {
+			if (required && selected.size === 0 && lockedValues.length === 0) return;
+			render("submit");
+			cleanup();
+			resolve([...lockedValues, ...Array.from(selected)]);
+		};
+		const cancel = () => {
+			render("cancel");
+			cleanup();
+			resolve(cancelSymbol);
+		};
+		const keypressHandler = (_str, key) => {
+			if (!key) return;
+			const filtered = getFiltered();
+			if (key.name === "return") {
+				submit();
+				return;
+			}
+			if (key.name === "escape" || key.ctrl && key.name === "c") {
+				cancel();
+				return;
+			}
+			if (key.name === "up") {
+				cursor = Math.max(0, cursor - 1);
+				render();
+				return;
+			}
+			if (key.name === "down") {
+				cursor = Math.min(filtered.length - 1, cursor + 1);
+				render();
+				return;
+			}
+			if (key.name === "space") {
+				const item = filtered[cursor];
+				if (item) if (selected.has(item.value)) selected.delete(item.value);
+				else selected.add(item.value);
+				render();
+				return;
+			}
+			if (key.name === "backspace") {
+				query = query.slice(0, -1);
+				cursor = 0;
+				render();
+				return;
+			}
+			if (key.sequence && !key.ctrl && !key.meta && key.sequence.length === 1) {
+				query += key.sequence;
+				cursor = 0;
+				render();
+				return;
+			}
+		};
+		process.stdin.on("keypress", keypressHandler);
+		render();
+	});
+}
+//#endregion
+//#region src/core/constants.ts
+const AGENTS_DIR = ".agents";
+const SKILLS_SUBDIR = "skills";
+//#endregion
+//#region src/core/installer.ts
+/**
+* Validates that a path is within an expected base directory
+* @param basePath - The expected base directory
+* @param targetPath - The path to validate
+* @returns true if targetPath is within basePath
+*/
+function isPathSafe(basePath, targetPath) {
+	const normalizedBase = normalize(resolve(basePath));
+	const normalizedTarget = normalize(resolve(targetPath));
+	return normalizedTarget.startsWith(normalizedBase + sep) || normalizedTarget === normalizedBase;
+}
+async function resolveParentSymlinks(path) {
+	const resolved = resolve(path);
+	const dir = dirname(resolved);
+	const base = basename(resolved);
+	try {
+		return join$1(await realpath(dir), base);
+	} catch {
+		return resolved;
+	}
+}
+function resolveSymlinkTarget(linkPath, linkTarget) {
+	return resolve(dirname(linkPath), linkTarget);
+}
+/**
+* Creates a symlink, handling cross-platform differences
+* Returns true if symlink was created, false if fallback to copy is needed
+*/
+async function createSymlink(target, linkPath) {
+	try {
+		const resolvedTarget = resolve(target);
+		const resolvedLinkPath = resolve(linkPath);
+		const [realTarget, realLinkPath] = await Promise.all([realpath(resolvedTarget).catch(() => resolvedTarget), realpath(resolvedLinkPath).catch(() => resolvedLinkPath)]);
+		if (realTarget === realLinkPath) return true;
+		if (await resolveParentSymlinks(target) === await resolveParentSymlinks(linkPath)) return true;
+		try {
+			if ((await lstat(linkPath)).isSymbolicLink()) {
+				if (resolveSymlinkTarget(linkPath, await readlink(linkPath)) === resolvedTarget) return true;
+				await rm(linkPath);
+			} else await rm(linkPath, { recursive: true });
+		} catch (err) {
+			if (err && typeof err === "object" && "code" in err && err.code === "ELOOP") try {
+				await rm(linkPath, { force: true });
+			} catch {}
+		}
+		const linkDir = dirname(linkPath);
+		await mkdir(linkDir, { recursive: true });
+		await symlink(relative(await resolveParentSymlinks(linkDir), target), linkPath, platform() === "win32" ? "junction" : void 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 清理并创建目录
+* @param path - 目录路径
+* @returns 创建成功返回 true
+*/
+async function cleanAndCreateDirectory(path) {
+	try {
+		await rm(path, {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+	await mkdir(path, { recursive: true });
+}
+/**
+* 下载并解压包
+* @param asset - 包信息
+* @param targetDir - 解压目标目录
+* @returns 解压成功返回 true
+*/
+async function downloadAndExtractPackage(asset, targetDir) {
+	let hasPackage = false;
+	const version = asset.currentVersion?.version ?? "";
+	if (!asset.slug || !version) {
+		generateSkillMd(asset, targetDir);
+		return false;
+	}
+	const pkgBuffer = await downloadSkillPackage(asset.slug, version);
+	if (pkgBuffer && pkgBuffer.length > 0) hasPackage = await extractPackage(pkgBuffer, targetDir);
+	if (!hasPackage) {
+		info("No package available, generating from metadata...");
+		generateSkillMd(asset, targetDir);
+		console.log("  Generated: SKILL.md from metadata");
+	}
+	return hasPackage;
+}
+function getAgentBaseDir(agentType, global, cwd) {
+	const agent = agents[agentType];
+	const baseDir = global ? homedir$1() : cwd || process.cwd();
+	if (global) {
+		if (agent.globalSkillsDir === void 0) return join$1(baseDir, agent.skillsDir);
+		return agent.globalSkillsDir;
+	}
+	return join$1(baseDir, agent.skillsDir);
+}
+async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
+	const agent = agents[agentType];
+	const isGlobal = options.global ?? false;
+	const cwd = options.cwd || process.cwd();
+	const installMode = options.mode ?? "symlink";
+	if (isGlobal && agent.globalSkillsDir === void 0) return {
+		success: false,
+		path: "",
+		mode: installMode,
+		error: `${agent.displayName} does not support global skill installation`
+	};
+	const skillName = sanitizeName(skill.slug);
+	const canonicalBase = getCanonicalSkillsDir(isGlobal, cwd);
+	const canonicalDir = join$1(canonicalBase, skillName);
+	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd);
+	const agentDir = join$1(agentBase, skillName);
+	if (!isPathSafe(canonicalBase, canonicalDir)) return {
+		success: false,
+		path: agentDir,
+		mode: installMode,
+		error: "Invalid skill name: potential path traversal detected"
+	};
+	if (!isPathSafe(agentBase, agentDir)) return {
+		success: false,
+		path: agentDir,
+		mode: installMode,
+		error: "Invalid skill name: potential path traversal detected"
+	};
+	async function populateSkillDir(targetDir) {
+		await downloadAndExtractPackage(skill, targetDir);
+	}
+	try {
+		if (installMode === "copy") {
+			await cleanAndCreateDirectory(agentDir);
+			await populateSkillDir(agentDir);
+			return {
+				success: true,
+				path: agentDir,
+				mode: "copy"
+			};
+		}
+		await cleanAndCreateDirectory(canonicalDir);
+		await populateSkillDir(canonicalDir);
+		if (!await createSymlink(canonicalDir, agentDir)) {
+			await cleanAndCreateDirectory(agentDir);
+			await cp(canonicalDir, agentDir, { recursive: true });
+			return {
+				success: true,
+				path: agentDir,
+				canonicalPath: canonicalDir,
+				mode: "symlink",
+				symlinkFailed: true
+			};
+		}
+		return {
+			success: true,
+			path: agentDir,
+			canonicalPath: canonicalDir,
+			mode: "symlink"
+		};
+	} catch (error) {
+		return {
+			success: false,
+			path: agentDir,
+			mode: installMode,
+			error: error instanceof Error ? error.message : "Unknown error"
+		};
+	}
+}
+function sanitizeName(name) {
+	return name.toLowerCase().replace(/[^a-z0-9._]+/g, "-").replace(/^[.\-]+|[.\-]+$/g, "").substring(0, 255) || "unnamed-skill";
+}
+function getCanonicalSkillsDir(global, cwd) {
+	return join$1(global ? homedir$1() : cwd || process.cwd(), AGENTS_DIR, SKILLS_SUBDIR);
+}
+/**
+* 将包从 buffer 解压到目标目录
+* 接口返回 zip 格式，兼容 tar.gz
+* @param buffer - 待解压的 buffer
+* @param targetDir - 解压目标目录
+* @returns 解压成功返回 true
+*/
+async function extractPackage(buffer, targetDir) {
+	await mkdir(targetDir, { recursive: true });
+	const tmpFile = join$1(tmpdir(), `openclawmp-pkg-${process.pid}-${Date.now()}`);
+	await writeFile(tmpFile, buffer);
+	try {
+		try {
+			execSync(`unzip -o -q "${tmpFile}" -d "${targetDir}" 2>/dev/null`, { stdio: "pipe" });
+			const entries = await readdir(targetDir);
+			const dirs = [];
+			for (const e of entries) if ((await stat(join$1(targetDir, e))).isDirectory()) dirs.push(e);
+			if (dirs.length === 1 && entries.length === 1) {
+				const subdir = join$1(targetDir, dirs[0]);
+				for (const f of await readdir(subdir)) await rename(join$1(subdir, f), join$1(targetDir, f));
+				await rm(subdir, { recursive: true });
+			}
+			return true;
+		} catch {
+			try {
+				execSync(`tar xzf "${tmpFile}" -C "${targetDir}" --strip-components=1 2>/dev/null`, { stdio: "pipe" });
+				return true;
+			} catch {
+				try {
+					execSync(`tar xzf "${tmpFile}" -C "${targetDir}" 2>/dev/null`, { stdio: "pipe" });
+					return true;
+				} catch {
+					return false;
+				}
+			}
+		}
+	} finally {
+		try {
+			await unlink(tmpFile);
+		} catch {}
+	}
+}
+function generateSkillMd(asset, targetDir) {
+	const tags = (asset.tags || []).join(", ");
+	const version = asset.currentVersion ?? asset.version ?? "";
+	const description = asset.summary || asset.description || "";
+	const content = `---
+name: ${asset.slug || asset.name || ""}
+display-name: ${asset.displayName || ""}
+description: ${description}
+version: ${version}
+author: ${asset.author?.name || ""}
+author-id: ${asset.author?.id || ""}
+tags: ${tags}
+category: ${asset.category || ""}
+---
+
+# ${asset.displayName || asset.slug || asset.name || "Skill"}
+
+${description}
+
+${asset.readme || ""}
+`;
+	writeFileSync$1(path$1.join(targetDir, "SKILL.md"), content);
+}
+//#endregion
+//#region src/commands/install.ts
+async function promptForAgents(message, choices, initialValues) {
+	return await searchMultiselect({
+		message,
+		items: choices,
+		leadingSpacer: 1,
+		initialSelected: initialValues
+	});
+}
+function cancelAndExit(message) {
+	p.cancel(message);
+	process.exit(0);
+}
+function errorAndExit(message, note) {
+	p.log.error(message);
+	if (note) p.note(note.body, note.title);
+	process.exit(1);
+}
+function buildAgentChoices(globalInstall) {
+	return Object.entries(agents).map(([key, config]) => ({
+		value: key,
+		label: config.displayName,
+		hint: globalInstall ? config.globalSkillsDir ?? config.skillsDir : config.skillsDir
+	}));
+}
+function getDefaultAgents(choices) {
+	return ["claude-code", "openclaw"].filter((agent) => choices.some((choice) => choice.value === agent));
+}
+async function resolveSkillName(inputSkill) {
+	if (inputSkill?.trim()) return inputSkill.trim();
+	const input = await p.text({
+		message: "Enter skill to install",
+		placeholder: "my-skill",
+		validate: (value) => {
+			if (!value?.trim()) return "Please enter skill name";
+		}
+	});
+	if (p.isCancel(input)) cancelAndExit("Cancelled");
+	return input.trim();
+}
+async function resolveTargetAgents(options) {
+	const allAgentChoices = buildAgentChoices(Boolean(options.global ?? options.yes));
+	if (options.yes) {
+		const defaults = getDefaultAgents(allAgentChoices);
+		if (defaults.length === 0) cancelAndExit("No default agents available");
+		return defaults;
+	}
+	const selected = await promptForAgents("Which agents do you want to install to?", allAgentChoices, getDefaultAgents(allAgentChoices));
+	if (p.isCancel(selected) || selected.length === 0) cancelAndExit("Installation cancelled");
+	return selected;
+}
+async function resolveInstallScope(options, targetAgents) {
+	const supportsGlobal = targetAgents.some((agent) => agents[agent].globalSkillsDir !== void 0);
+	if (options.global !== void 0 || options.yes || !supportsGlobal) return options.global ?? (options.yes ? true : false);
+	const scope = await p.select({
+		message: "Installation scope",
+		options: [{
+			value: false,
+			label: "Project",
+			hint: "Install in current directory (committed with your project)"
+		}, {
+			value: true,
+			label: "Global",
+			hint: "Install in home directory (available across all projects)"
+		}]
+	});
+	if (p.isCancel(scope)) cancelAndExit("Installation cancelled");
+	return scope;
+}
+const run = async (args, options = {}) => {
+	p.intro(chalk.bold("skill-atlas install"));
+	const skill = await resolveSkillName(args[0]);
+	const s = p.spinner();
+	s.start(`Searching for ${chalk.bold(skill)}...`);
+	try {
+		const asset = await findAsset(skill);
+		if (!asset) {
+			s.stop();
+			errorAndExit(`Not found: ${chalk.bold(skill)}`, {
+				title: "Suggest",
+				body: `Try: skill-atlas search ${skill}`
+			});
+		}
+		const displayName = asset.displayName || asset.slug;
+		const version = asset.currentVersion.version ?? "0.0.0";
+		s.stop(`${chalk.bold(displayName)} ${chalk.dim(`v${version}`)}`);
+		const targetAgents = await resolveTargetAgents(options);
+		const installGlobally = await resolveInstallScope(options, targetAgents);
+		const selectedLabels = targetAgents.map((a) => agents[a].displayName);
+		p.log.message(chalk.green("Selected:") + " " + selectedLabels.join(", "));
+		s.start("Installing skills...");
+		const installMode = options.copy ? "copy" : "symlink";
+		const installResults = [];
+		for (const agent of targetAgents) {
+			const result = await installWellKnownSkillForAgent(asset, agent, {
+				global: installGlobally,
+				mode: installMode
+			});
+			if (!result.success) throw new Error(`Failed to install to ${agents[agent].displayName}: ${result.error || "Unknown error"}`);
+			installResults.push({
+				agent,
+				path: result.path
+			});
+		}
+		s.stop("Skills installed successfully");
+		const title = import_picocolors.default.green("Installed 1 skill");
+		const resultLines = installResults.map((r) => `  ${agents[r.agent].displayName}: ${r.path}`);
+		p.note(resultLines.join("\n"), title);
+		p.outro(import_picocolors.default.green("Done!") + import_picocolors.default.dim("  Skill ready. Review before use."));
+	} catch (err) {
+		s.stop();
+		p.log.error(`Install failed: ${err.message}`);
+		process.exit(1);
+	}
+};
+var install_default = { run };
+//#endregion
+//#region src/commands/search.ts
+function getVersion(skill) {
+	const cv = skill.currentVersion;
+	if (typeof cv === "string") return cv;
+	if (cv && typeof cv === "object" && "version" in cv) return cv.version ?? "—";
+	return "—";
+}
+function printSkillList(items, total, page, pageSize) {
+	const maxSlugLen = Math.max(...items.map((s) => (s.slug || "").length), 6);
+	const maxDescLen = Math.max(...items.map((s) => Math.min((s.displayName || "—").length, 30)), 8);
+	const header = `  ${chalk.bold("Description".padEnd(maxDescLen))}  ${chalk.bold("SkillName".padEnd(maxSlugLen))}    ${chalk.bold("Version")}`;
+	const separator = "  " + "-".repeat(maxSlugLen + maxDescLen + 12);
+	const resultLines = items.map((s) => {
+		const slug = (s.slug || "—").padEnd(maxSlugLen);
+		const descPadded = ((s.displayName || "—").length > 30 ? (s.displayName || "—").slice(0, 27) + "..." : s.displayName || "—").padEnd(maxDescLen);
+		const version = getVersion(s);
+		return `  ${chalk.white(descPadded)}  ${chalk.cyan.bold(slug)}   ${chalk.dim(`v${version}`)}`;
+	});
+	p.note([
+		header,
+		separator,
+		...resultLines
+	].join("\n"), chalk.green(`Found ${total} skill(s)`));
+	const start = (page - 1) * pageSize + 1;
+	const end = Math.min(page * pageSize, total);
+	p.log.message(chalk.dim(`Showing ${start}-${end} of ${total}`));
+	p.log.message(chalk.green(`Install: npx skill-atlas install <skillName>`));
+}
+async function runSearch(options) {
+	const { keyword } = options;
+	try {
+		const result = await searchSkills({ q: keyword });
+		const { items, total } = result;
+		if (items.length === 0) {
+			p.log.error(`No skills found matching "${chalk.bold(keyword)}"`);
+			return;
+		}
+		printSkillList(items, total, result.page, result.pageSize);
+	} catch (err) {
+		p.log.error(`Search failed: ${err.message}`);
+		process.exit(1);
+	}
+}
+//#endregion
+//#region src/core/logger.ts
+const consola = createConsola();
+/**
+* 设置 verbose 模式（启用 debug 输出）
+* consola level: 3=info, 4=debug
+*/
+function setVerbose(enabled) {
+	consola.level = enabled ? 4 : 3;
+}
+/**
+* 检查是否启用 verbose
+*/
+function isVerbose() {
+	return consola.level >= 4;
+}
+/**
+* 错误别名（兼容 err 调用）
+*/
+function err(...args) {
+	consola.error.apply(consola, args);
+}
+var logger_default = {
+	setVerbose,
+	isVerbose,
+	info: ((...a) => consola.info(...a)),
+	success: ((...a) => consola.success(...a)),
+	warn: ((...a) => consola.warn(...a)),
+	error: ((...a) => consola.error(...a)),
+	err,
+	debug: ((...a) => consola.debug(...a)),
+	log: ((...a) => consola.log(...a))
+};
+//#endregion
+export { checkForUpdate, install_default as install, logger_default as logger, runSearch };