@empjs/skill 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -237,11 +237,12 @@ function agents() {
 }
 
 // src/commands/install.ts
-var import_node_child_process2 = require("child_process");
-var import_node_fs6 = __toESM(require("fs"), 1);
-var import_node_os3 = __toESM(require("os"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
-var import_node_util2 = require("util");
+var import_node_child_process = require("child_process");
+var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var import_node_util = require("util");
+var import_enquirer = __toESM(require("enquirer"), 1);
+var import_chalk3 = __toESM(require("chalk"), 1);
 
 // src/utils/git.ts
 function parseGitUrl(url) {
@@ -268,27 +269,25 @@ function parseGitUrl(url) {
       const owner = match[1];
       const repo = match[2].replace(/\.git$/, "");
       let branch;
-      let path7;
-      let gitUrl;
+      let path8;
       if (i === 0) {
         branch = match[3];
-        path7 = match[4];
-        gitUrl = `https://github.com/${owner}/${repo}.git`;
+        path8 = match[4];
       } else if (i === 1) {
         branch = "main";
-        gitUrl = `https://github.com/${owner}/${repo}.git`;
       } else {
         branch = "main";
-        gitUrl = url.includes(".git") ? url : `git@github.com:${owner}/${repo}.git`;
       }
+      const gitUrl = `https://github.com/${owner}/${repo}.git`;
       return {
         type: "github",
         owner,
         repo,
         branch,
-        path: path7,
+        path: path8,
         gitUrl,
         installUrl: gitUrl
+        // Will be used for git clone
       };
     }
   }
@@ -299,13 +298,13 @@ function parseGitUrl(url) {
       let owner;
       let repo;
       let branch;
-      let path7;
+      let path8;
       let gitUrl;
       if (i === 0) {
         const host = match[1];
         const repoPath = match[2].replace(/\.git$/, "");
         branch = match[3];
-        path7 = match[4];
+        path8 = match[4];
         const parts = repoPath.split("/");
         repo = parts.pop() || repoPath;
         owner = parts.join("/") || repo;
@@ -322,14 +321,14 @@ function parseGitUrl(url) {
         const parts = repoPath.split("/");
         repo = parts.pop() || repoPath;
         owner = parts.join("/") || repo;
-        gitUrl = url.includes(".git") ? url : `git@${host}:${repoPath}.git`;
+        gitUrl = `https://${host}/${repoPath}.git`;
       }
       return {
         type: "gitlab",
         owner,
         repo,
         branch,
-        path: path7,
+        path: path8,
         gitUrl,
         installUrl: gitUrl
       };
@@ -346,6 +345,16 @@ function parseGitUrl(url) {
   }
   return null;
 }
+function convertToSshUrl(httpsUrl) {
+  try {
+    const url = new URL(httpsUrl);
+    if (url.protocol !== "https:" && url.protocol !== "http:") return null;
+    const path8 = url.pathname.startsWith("/") ? url.pathname.substring(1) : url.pathname;
+    return `git@${url.hostname}:${path8}`;
+  } catch {
+    return null;
+  }
+}
 function isGitUrl(str) {
   return str.includes("github.com") || str.includes("gitlab.com") || str.includes("/-/tree/") || // GitLab web URL pattern (self-hosted)
   str.startsWith("git@") || str.startsWith("git+") || str.startsWith("git://");
@@ -454,110 +463,49 @@ function extractSkillName(nameOrPath) {
   return import_node_path2.default.basename(nameOrPath);
 }
 
-// src/utils/registry.ts
-var import_node_child_process = require("child_process");
+// src/utils/symlink.ts
 var import_node_fs4 = __toESM(require("fs"), 1);
 var import_node_path3 = __toESM(require("path"), 1);
-var import_node_util = require("util");
-var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
-function findNpmrc(startDir) {
-  let currentDir = import_node_path3.default.resolve(startDir);
-  while (currentDir !== import_node_path3.default.dirname(currentDir)) {
-    const npmrcPath = import_node_path3.default.join(currentDir, ".npmrc");
-    if (import_node_fs4.default.existsSync(npmrcPath)) {
-      return npmrcPath;
-    }
-    currentDir = import_node_path3.default.dirname(currentDir);
-  }
-  return null;
-}
-function parseNpmrc(npmrcPath) {
-  try {
-    const content = import_node_fs4.default.readFileSync(npmrcPath, "utf-8");
-    const lines = content.split("\n");
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) {
-        continue;
-      }
-      const registryMatch = trimmed.match(/^(?:@[^:]+:)?registry\s*=\s*(.+)$/);
-      if (registryMatch) {
-        return registryMatch[1].trim();
-      }
-    }
-  } catch (error) {
-  }
-  return null;
-}
-async function getGlobalRegistry() {
-  try {
-    const { stdout } = await execAsync("npm config get registry");
-    const registry = stdout.trim();
-    if (registry && registry !== "undefined") {
-      return registry;
-    }
-  } catch (error) {
-  }
-  return null;
-}
-async function getRegistry(cwd = process.cwd()) {
-  const npmrcPath = findNpmrc(cwd);
-  if (npmrcPath) {
-    const registry = parseNpmrc(npmrcPath);
-    if (registry) {
-      return registry;
-    }
-  }
-  const globalRegistry = await getGlobalRegistry();
-  if (globalRegistry) {
-    return globalRegistry;
-  }
-  return "https://registry.npmjs.org/";
-}
-
-// src/utils/symlink.ts
-var import_node_fs5 = __toESM(require("fs"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
 function copyDir(src, dest) {
-  import_node_fs5.default.mkdirSync(dest, { recursive: true });
-  const entries = import_node_fs5.default.readdirSync(src, { withFileTypes: true });
+  import_node_fs4.default.mkdirSync(dest, { recursive: true });
+  const entries = import_node_fs4.default.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-    const srcPath = import_node_path4.default.join(src, entry.name);
-    const destPath = import_node_path4.default.join(dest, entry.name);
+    const srcPath = import_node_path3.default.join(src, entry.name);
+    const destPath = import_node_path3.default.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDir(srcPath, destPath);
     } else {
-      import_node_fs5.default.copyFileSync(srcPath, destPath);
+      import_node_fs4.default.copyFileSync(srcPath, destPath);
     }
   }
 }
-function createSymlink(skillName, agent, cwd) {
+function createSymlink(skillName, agent, cwd, useCopyOverride) {
   const source = getSharedSkillPath(skillName);
-  if (!import_node_fs5.default.existsSync(source)) {
+  if (!import_node_fs4.default.existsSync(source)) {
     logger.error(`Skill not found: ${source}`);
     return false;
   }
   const targets = getAgentSkillPaths(agent.name, skillName, cwd);
-  const useCopy = agent.useCopyInsteadOfSymlink === true;
+  const useCopy = useCopyOverride !== void 0 ? useCopyOverride : agent.useCopyInsteadOfSymlink === true;
   let successCount = 0;
   for (const target of targets) {
-    const targetDir = import_node_path4.default.dirname(target);
-    if (!import_node_fs5.default.existsSync(targetDir)) {
+    const targetDir = import_node_path3.default.dirname(target);
+    if (!import_node_fs4.default.existsSync(targetDir)) {
       try {
-        import_node_fs5.default.mkdirSync(targetDir, { recursive: true });
+        import_node_fs4.default.mkdirSync(targetDir, { recursive: true });
       } catch (error) {
         logger.error(`Failed to create directory ${targetDir}: ${error.message}`);
         continue;
       }
     }
-    if (import_node_fs5.default.existsSync(target)) {
+    if (import_node_fs4.default.existsSync(target)) {
       try {
-        const stats = import_node_fs5.default.lstatSync(target);
+        const stats = import_node_fs4.default.lstatSync(target);
         if (stats.isSymbolicLink()) {
-          import_node_fs5.default.unlinkSync(target);
+          import_node_fs4.default.unlinkSync(target);
         } else if (stats.isDirectory()) {
-          import_node_fs5.default.rmSync(target, { recursive: true, force: true });
+          import_node_fs4.default.rmSync(target, { recursive: true, force: true });
         } else {
           logger.warn(`Target exists but is not a symlink/dir, skipping: ${target}`);
           continue;
@@ -571,7 +519,7 @@ function createSymlink(skillName, agent, cwd) {
       if (useCopy) {
         copyDir(source, target);
       } else {
-        import_node_fs5.default.symlinkSync(source, target, "dir");
+        import_node_fs4.default.symlinkSync(source, target, "dir");
       }
       successCount++;
     } catch (error) {
@@ -589,16 +537,16 @@ function removeSymlink(skillName, agent, cwd) {
   const targets = getAgentSkillPaths(agent.name, skillName, cwd);
   let removedCount = 0;
   for (const target of targets) {
-    if (!import_node_fs5.default.existsSync(target)) {
+    if (!import_node_fs4.default.existsSync(target)) {
       continue;
     }
     try {
-      const stats = import_node_fs5.default.lstatSync(target);
+      const stats = import_node_fs4.default.lstatSync(target);
       if (stats.isSymbolicLink()) {
-        import_node_fs5.default.unlinkSync(target);
+        import_node_fs4.default.unlinkSync(target);
         removedCount++;
       } else if (stats.isDirectory()) {
-        import_node_fs5.default.rmSync(target, { recursive: true, force: true });
+        import_node_fs4.default.rmSync(target, { recursive: true, force: true });
         removedCount++;
       } else {
         logger.warn(`Not a symlink or directory: ${target}`);
@@ -616,7 +564,7 @@ function removeSymlink(skillName, agent, cwd) {
 }
 function isSymlink(filePath) {
   try {
-    const stats = import_node_fs5.default.lstatSync(filePath);
+    const stats = import_node_fs4.default.lstatSync(filePath);
     return stats.isSymbolicLink();
   } catch {
     return false;
@@ -624,426 +572,493 @@ function isSymlink(filePath) {
 }
 function readSymlink(filePath) {
   try {
-    return import_node_fs5.default.readlinkSync(filePath);
+    return import_node_fs4.default.readlinkSync(filePath);
   } catch {
     return null;
   }
 }
 
+// src/utils/collection.ts
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+function scanForSkills(dir) {
+  const skills = [];
+  const skillMdPath = import_node_path4.default.join(dir, "SKILL.md");
+  if (import_node_fs5.default.existsSync(skillMdPath)) {
+    skills.push(parseSkillDir(dir));
+  }
+  const entries = import_node_fs5.default.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+      const subDir = import_node_path4.default.join(dir, entry.name);
+      const subSkillMd = import_node_path4.default.join(subDir, "SKILL.md");
+      if (import_node_fs5.default.existsSync(subSkillMd)) {
+        skills.push(parseSkillDir(subDir));
+      }
+    }
+  }
+  return skills;
+}
+function parseSkillDir(dir) {
+  const name = import_node_path4.default.basename(dir);
+  let description = "";
+  let version2 = "1.0.0";
+  const pkgPath = import_node_path4.default.join(dir, "package.json");
+  if (import_node_fs5.default.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(import_node_fs5.default.readFileSync(pkgPath, "utf-8"));
+      if (pkg.description) description = pkg.description;
+      if (pkg.version) version2 = pkg.version;
+      if (pkg.name) {
+        return {
+          name: pkg.name.replace("@empjs/", ""),
+          path: dir,
+          description,
+          version: version2
+        };
+      }
+    } catch {
+    }
+  }
+  const skillMdPath = import_node_path4.default.join(dir, "SKILL.md");
+  if (import_node_fs5.default.existsSync(skillMdPath)) {
+    const content = import_node_fs5.default.readFileSync(skillMdPath, "utf-8");
+    const descMatch = content.match(/description:\s*(?:"([^"]+)"|'([^']+)'|([^'"\n\r]+))/i);
+    if (descMatch) {
+      description = descMatch[1] || descMatch[2] || descMatch[3];
+    }
+  }
+  return {
+    name,
+    path: dir,
+    description: description.trim(),
+    version: version2
+  };
+}
+
+// src/utils/config.ts
+var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_node_os3 = __toESM(require("os"), 1);
+var CONFIG_DIR = import_node_path5.default.join(import_node_os3.default.homedir(), ".emp-agent");
+var CONFIG_FILE2 = import_node_path5.default.join(CONFIG_DIR, "config.json");
+var DEFAULT_LANG = Intl.DateTimeFormat().resolvedOptions().locale.startsWith("zh") ? "zh" : "en";
+var DEFAULT_CONFIG = {
+  sources: [],
+  tokens: {},
+  lang: DEFAULT_LANG
+};
+function getLang() {
+  return loadConfig().lang || DEFAULT_LANG;
+}
+function saveToken(domain, token) {
+  const config = loadConfig();
+  config.tokens[domain] = token;
+  saveConfig(config);
+}
+function getToken(domain) {
+  const config = loadConfig();
+  return config.tokens[domain];
+}
+function ensureConfigDir() {
+  if (!import_node_fs6.default.existsSync(CONFIG_DIR)) {
+    import_node_fs6.default.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  ensureConfigDir();
+  if (!import_node_fs6.default.existsSync(CONFIG_FILE2)) {
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const content = import_node_fs6.default.readFileSync(CONFIG_FILE2, "utf-8");
+    return { ...DEFAULT_CONFIG, ...JSON.parse(content) };
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  import_node_fs6.default.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2));
+}
+
+// src/utils/i18n.ts
+var translations = {
+  en: {
+    analyzing: "Analyzing:",
+    fetching: "Fetching skills from source...",
+    sourceReady: "Source ready",
+    foundSkills: "Found {count} skills:",
+    selectSkills: "Select skills to install",
+    selectScope: "Where do you want to install?",
+    selectMethod: "How do you want to install?",
+    globalScope: "Global (~/.claude, ~/.cursor, etc.)",
+    localScope: "Local Project (./.agent/skills)",
+    linkMethod: "Symlink (Changes reflect instantly)",
+    copyMethod: "Full Copy (Self-contained)",
+    installing: "Installing {name}...",
+    processing: "Processing {name}...",
+    success: "{count} skill(s) installed successfully!",
+    authRequired: "Authentication required for {domain}",
+    enterToken: "Please enter Access Token for {domain}:",
+    authenticating: "Authenticating with {domain}...",
+    clonedSuccess: "Cloned successfully",
+    noAgents: "No AI agents detected for the selected scope.",
+    linkedTo: "Linked to: {agents}",
+    notLinked: "Not linked to any agent",
+    source: "Source:",
+    installed: "INSTALLED",
+    devLink: "DEV LINK",
+    unsupported: "Invalid git URL: {url}",
+    back: "Back",
+    backHint: "(Press Esc or select Back to go back)",
+    selectAtLeastOne: "Please select at least one skill."
+  },
+  zh: {
+    analyzing: "\u6B63\u5728\u5206\u6790:",
+    fetching: "\u6B63\u5728\u4ECE\u6E90\u83B7\u53D6\u6280\u80FD...",
+    sourceReady: "\u83B7\u53D6\u6210\u529F",
+    foundSkills: "\u53D1\u73B0 {count} \u4E2A\u6280\u80FD:",
+    selectSkills: "\u8BF7\u9009\u62E9\u8981\u5B89\u88C5\u7684\u6280\u80FD",
+    selectScope: "\u60A8\u5E0C\u671B\u5B89\u88C5\u5230\u54EA\u91CC\uFF1F",
+    selectMethod: "\u60A8\u5E0C\u671B\u5982\u4F55\u5B89\u88C5\uFF1F",
+    globalScope: "\u5168\u5C40\u76EE\u5F55 (~/.claude, ~/.cursor \u7B49)",
+    localScope: "\u5F53\u524D\u9879\u76EE (./.agent/skills)",
+    linkMethod: "\u8F6F\u94FE\u63A5 (\u4FEE\u6539\u5B9E\u65F6\u751F\u6548)",
+    copyMethod: "\u5168\u91CF\u590D\u5236 (\u79BB\u7EBF/\u72EC\u7ACB)",
+    installing: "\u6B63\u5728\u5B89\u88C5 {name}...",
+    processing: "\u6B63\u5728\u5904\u7406 {name}...",
+    success: "\u6210\u529F\u5B89\u88C5\u4E86 {count} \u4E2A\u6280\u80FD\uFF01",
+    authRequired: "\u9700\u8981\u9274\u6743: {domain}",
+    enterToken: "\u8BF7\u8F93\u5165 {domain} \u7684\u8BBF\u95EE\u4EE4\u724C (Access Token):",
+    authenticating: "\u6B63\u5728\u9A8C\u8BC1 {domain} \u7684\u9274\u6743\u4FE1\u606F...",
+    clonedSuccess: "\u83B7\u53D6\u6210\u529F",
+    noAgents: "\u5728\u9009\u5B9A\u8303\u56F4\u5185\u672A\u68C0\u6D4B\u5230 AI Agent \u76EE\u5F55\u3002",
+    linkedTo: "\u5DF2\u94FE\u63A5\u81F3: {agents}",
+    notLinked: "\u672A\u94FE\u63A5\u5230\u4EFB\u4F55 Agent",
+    source: "\u6E90\u8DEF\u5F84:",
+    installed: "\u5DF2\u5B89\u88C5",
+    devLink: "\u5F00\u53D1\u94FE\u63A5",
+    unsupported: "\u65E0\u6548\u7684 Git URL: {url}",
+    back: "\u8FD4\u56DE",
+    backHint: "(\u6309 Esc \u6216\u9009\u62E9\u201C\u8FD4\u56DE\u201D\u4EE5\u56DE\u5230\u4E0A\u4E00\u6B65)",
+    selectAtLeastOne: "\u8BF7\u81F3\u5C11\u9009\u62E9\u4E00\u4E2A\u6280\u80FD\u3002"
+  }
+};
+function t(key, params = {}) {
+  const lang = getLang();
+  let text = translations[lang][key] || translations.en[key] || key;
+  for (const [p, val] of Object.entries(params)) {
+    text = text.replace(`{${p}}`, String(val));
+  }
+  return text;
+}
+
 // src/commands/install.ts
-var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.exec);
+var { MultiSelect, Password, Select } = import_enquirer.default;
+var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
 async function execWithTimeout(command, timeout = 12e4, env) {
   let timeoutId = null;
   const timeoutPromise = new Promise((_, reject) => {
-    timeoutId = setTimeout(() => {
-      reject(new Error(`Command timeout after ${timeout / 1e3}s`));
-    }, timeout);
+    timeoutId = setTimeout(() => reject(new Error(`Timeout ${timeout / 1e3}s`)), timeout);
   });
   try {
-    const execOptions = env ? { env } : {};
-    const result = await Promise.race([execAsync2(command, execOptions), timeoutPromise]);
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-    return result;
-  } catch (error) {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-    throw error;
+    const res = await Promise.race([execAsync(command, env ? { env } : {}), timeoutPromise]);
+    if (timeoutId) clearTimeout(timeoutId);
+    return res;
+  } catch (e) {
+    if (timeoutId) clearTimeout(timeoutId);
+    throw e;
   }
 }
+async function promptSkills(skills) {
+  const prompt = new MultiSelect({
+    name: "value",
+    message: t("selectSkills"),
+    choices: skills.map((s) => ({
+      name: s.name,
+      enabled: true,
+      message: `${s.name.substring(0, 20)}${import_chalk3.default.dim((s.description ? " - " + s.description : "").substring(0, 40))}`
+    })),
+    pointer(state, choice) {
+      return state.index === choice.index ? import_chalk3.default.cyan("\u276F") : " ";
+    },
+    indicator(state, choice) {
+      return choice.enabled ? import_chalk3.default.green("[\u2714]") : import_chalk3.default.gray("[ ]");
+    },
+    footer: import_chalk3.default.dim(`
+  (\u7A7A\u683C\u52FE\u9009, A \u5168\u9009, Enter \u786E\u8BA4, Esc \u9000\u51FA)`),
+    validate(value) {
+      if (value.length === 0) return import_chalk3.default.red(t("selectAtLeastOne"));
+      return true;
+    }
+  });
+  return prompt.run();
+}
+async function promptSelect(message, choices) {
+  const prompt = new Select({
+    name: "value",
+    message,
+    choices: [...choices, { name: "back", message: import_chalk3.default.yellow("\u2190 " + t("back")) }],
+    pointer(state, choice) {
+      return state.index === choice.index ? import_chalk3.default.cyan("\u276F") : " ";
+    },
+    footer: import_chalk3.default.dim(`
+  ${t("backHint")}`)
+  });
+  return prompt.run();
+}
 async function install(skillNameOrPath, options = {}) {
   const isGit = isGitUrl(skillNameOrPath);
-  if (isGit) {
-    logger.info("Installing from Git URL");
-    logger.dim(skillNameOrPath);
-  } else {
-    logger.info(`Installing skill: ${skillNameOrPath}`);
-  }
+  logger.info(`${import_chalk3.default.cyan("\u{1F50D}")} ${t("analyzing")} ${import_chalk3.default.bold(skillNameOrPath)}`);
   ensureSharedDir();
-  let skillPath;
-  let skillName;
-  if (process.env.DEBUG_ESKILL) {
-    logger.dim(`[DEBUG] isGitUrl=${isGit}, parseGitUrl=${parseGitUrl(skillNameOrPath) ? "ok" : "null"}`);
-  }
+  let tempDir = "";
+  let cloneDir = "";
+  let availableSkills = [];
   if (isGit) {
     const gitInfo = parseGitUrl(skillNameOrPath);
     if (!gitInfo) {
-      logger.error(`Invalid git URL: ${skillNameOrPath}`);
-      logger.info("Please ensure the URL is a valid GitHub or GitLab repository URL");
+      logger.error(t("unsupported", { url: skillNameOrPath }));
       process.exit(1);
     }
-    skillName = gitInfo.path ? extractSkillName(import_node_path5.default.basename(gitInfo.path)) : extractSkillName(gitInfo.repo);
-    const tempDir = import_node_path5.default.join("/tmp", `eskill-${Date.now()}`);
-    const cloneDir = import_node_path5.default.join(tempDir, "repo");
+    tempDir = import_node_path6.default.join("/tmp", `eskill-${Date.now()}`);
+    cloneDir = import_node_path6.default.join(tempDir, "repo");
     try {
-      const timeout = options.timeout || 12e4;
-      const gitDetails = [`${gitInfo.gitUrl}`];
-      if (gitInfo.branch) gitDetails.push(`branch: ${gitInfo.branch}`);
-      if (gitInfo.path) gitDetails.push(`path: ${gitInfo.path}`);
-      logger.dim(gitDetails.join(" \xB7 "));
-      const spinner = logger.start(`Cloning...`);
-      import_node_fs6.default.mkdirSync(tempDir, { recursive: true });
-      const branchFlag = gitInfo.branch ? `-b ${gitInfo.branch}` : "";
-      const cloneCommand = branchFlag ? `git clone ${branchFlag} ${gitInfo.gitUrl} ${cloneDir} --depth 1 --quiet` : `git clone ${gitInfo.gitUrl} ${cloneDir} --depth 1 --quiet`;
+      const spinner = logger.start(t("fetching"));
+      import_node_fs7.default.mkdirSync(tempDir, { recursive: true });
+      const domain = new URL(gitInfo.gitUrl).hostname;
+      let gitUrl = gitInfo.gitUrl;
+      const token = getToken(domain) || process.env[`ESKILL_TOKEN_${domain.toUpperCase().replace(/\./g, "_")}`];
+      const doClone = async (u) => execWithTimeout(`git clone ${gitInfo.branch ? "-b " + gitInfo.branch : ""} ${u} ${cloneDir} --depth 1 --quiet`, options.timeout || 12e4);
       try {
-        await execWithTimeout(cloneCommand, timeout);
-        spinner.succeed(`Cloned successfully`);
-      } catch (error) {
-        spinner.fail("Clone failed");
-        if (error.message.includes("timeout")) {
-          logger.error(`Clone timeout after ${timeout / 1e3} seconds`);
-          logger.info("");
-          logger.info("Possible reasons:");
-          logger.info("  - Slow network connection");
-          logger.info("  - Large repository size");
-          logger.info("  - Git server issues");
-          logger.info("");
-          logger.info(`Try again or increase timeout: eskill add ${skillNameOrPath} --timeout=300000`);
-        }
-        throw error;
-      }
-      if (gitInfo.path) {
-        skillPath = import_node_path5.default.join(cloneDir, gitInfo.path);
-        if (!import_node_fs6.default.existsSync(skillPath)) {
-          logger.error(`Path not found in repository: ${gitInfo.path}`);
-          logger.info(`Repository cloned to: ${cloneDir}`);
-          process.exit(1);
+        let finalUrl = gitUrl;
+        if (token && gitUrl.startsWith("https://")) finalUrl = gitUrl.replace("https://", `https://oauth2:${token}@`);
+        await doClone(finalUrl);
+        spinner.succeed(t("sourceReady"));
+      } catch (e) {
+        const sshUrl = convertToSshUrl(gitUrl);
+        if (sshUrl) {
+          try {
+            await doClone(sshUrl);
+            spinner.succeed(t("sourceReady"));
+          } catch {
+            spinner.stop();
+            logger.warn(`
+\u{1F512} ${t("authRequired", { domain })}`);
+            const newToken = await new Password({ message: t("enterToken", { domain }), validate: (v) => v.length > 0 }).run();
+            saveToken(domain, newToken);
+            const authedUrl = gitUrl.replace("https://", `https://oauth2:${newToken}@`);
+            const fs10 = logger.start(t("fetching"));
+            await performClone(authedUrl);
+            fs10.succeed(t("sourceReady"));
+          }
+        } else {
+          spinner.fail("Clone failed");
+          throw e;
         }
-      } else {
-        skillPath = cloneDir;
-      }
-      const skillMdPath = import_node_path5.default.join(skillPath, "SKILL.md");
-      if (!import_node_fs6.default.existsSync(skillMdPath)) {
-        logger.warn(`Warning: SKILL.md not found in ${skillPath}`);
-        logger.info("The directory may not be a valid skill package");
       }
+      availableSkills = scanForSkills(gitInfo.path ? import_node_path6.default.join(cloneDir, gitInfo.path) : cloneDir);
     } catch (error) {
-      logger.error(`Failed to clone repository: ${error.message}`);
-      if (error.message.includes("timeout")) {
-        logger.error(`Clone timeout after 2 minutes`);
-        logger.info("This might be due to:");
-        logger.info("  - Slow network connection");
-        logger.info("  - Large repository size");
-        logger.info("  - Git server issues");
-        logger.info(`
-Try again or check your network connection`);
-      }
-      logger.info(`
-Tried to clone: ${gitInfo.gitUrl}`);
-      if (gitInfo.branch) {
-        logger.info(`Branch: ${gitInfo.branch}`);
-      }
+      logger.error(`Error: ${error.message}`);
       process.exit(1);
     }
-  } else if (options.link || import_node_fs6.default.existsSync(skillNameOrPath)) {
-    skillPath = import_node_path5.default.resolve(skillNameOrPath);
-    if (!import_node_fs6.default.existsSync(skillPath)) {
+  } else {
+    const skillPath = import_node_path6.default.resolve(skillNameOrPath);
+    if (!import_node_fs7.default.existsSync(skillPath)) {
       logger.error(`Path not found: ${skillPath}`);
       process.exit(1);
     }
-    const pkgPath = import_node_path5.default.join(skillPath, "package.json");
-    if (import_node_fs6.default.existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(import_node_fs6.default.readFileSync(pkgPath, "utf-8"));
-        skillName = extractSkillName(pkg.name);
-      } catch {
-        skillName = extractSkillName(import_node_path5.default.basename(skillPath));
-      }
-    } else {
-      skillName = extractSkillName(import_node_path5.default.basename(skillPath));
-    }
-  } else {
-    skillName = extractSkillName(skillNameOrPath);
-    const tempDir = import_node_path5.default.join("/tmp", `eskill-${Date.now()}`);
+    availableSkills = scanForSkills(skillPath);
+  }
+  if (availableSkills.length === 0) {
+    logger.error("No skills found");
+    process.exit(1);
+  }
+  let step = availableSkills.length === 1 ? 1 : 0;
+  let selectedNames = [availableSkills[0]?.name];
+  let installScope = options.local ? "local" : "global";
+  let installMethod = options.copy ? "copy" : "link";
+  while (step < 3) {
     try {
-      const registry = options.registry || await getRegistry();
-      const timeout = options.timeout || 18e4;
-      const spinner = logger.start(`Installing ${skillNameOrPath}...`);
-      logger.infoWithoutStop(`Registry: ${registry}`);
-      logger.infoWithoutStop(`Timeout: ${timeout / 1e3}s`);
-      import_node_fs6.default.mkdirSync(tempDir, { recursive: true });
-      logger.updateSpinner(`Downloading ${skillNameOrPath} from ${registry}...`);
-      const homeDir = process.env.HOME || process.env.USERPROFILE || import_node_os3.default.homedir();
-      const npmCacheDir = import_node_path5.default.join(homeDir, ".npm");
-      const npmConfigPrefix = import_node_path5.default.join(homeDir, ".npm-global");
-      import_node_fs6.default.mkdirSync(npmCacheDir, { recursive: true });
-      const installCommand = `npm install ${skillNameOrPath} --prefix ${tempDir} --registry=${registry} --no-save --silent --no-bin-links --prefer-offline`;
-      const env = {
-        ...process.env,
-        npm_config_cache: npmCacheDir,
-        npm_config_prefix: npmConfigPrefix,
-        npm_config_global: "false"
-      };
-      try {
-        await execWithTimeout(installCommand, timeout, env);
-        spinner.succeed(`Package ${skillNameOrPath} downloaded successfully`);
-      } catch (error) {
-        spinner.fail("Download failed");
-        const errorMessage = error.message || error.stderr || "";
-        if (errorMessage.includes("timeout")) {
-          logger.error(`Download timeout after ${timeout / 1e3} seconds`);
-          logger.info("");
-          logger.info("Possible reasons:");
-          logger.info("  - Slow network connection");
-          logger.info("  - Registry server issues or unresponsive");
-          logger.info("  - Large package size");
-          logger.info("  - Network firewall blocking the connection");
-          logger.info("");
-          logger.info("Suggestions:");
-          logger.info(`  - Try again: eskill add ${skillNameOrPath}`);
-          logger.info(
-            `  - Use a different registry: eskill add ${skillNameOrPath} --registry=https://registry.npmjs.org/`
-          );
-          logger.info(`  - Increase timeout: eskill add ${skillNameOrPath} --timeout=300000`);
-        } else if (errorMessage.includes("EACCES") || errorMessage.includes("permission denied") || errorMessage.includes("Permission denied")) {
-          logger.error("Permission denied error detected");
-          logger.info("");
-          logger.info("This error occurs when npm tries to access system directories.");
-          logger.info("");
-          logger.info("\u{1F527} Quick Fix (Recommended):");
-          logger.info("");
-          logger.info("1. Configure npm to use user directory:");
-          logger.info(`   mkdir -p ${npmConfigPrefix}`);
-          logger.info(`   npm config set prefix '${npmConfigPrefix}'`);
-          logger.info("");
-          logger.info("2. Add to your ~/.zshrc (or ~/.bash_profile):");
-          logger.info(`   export PATH="${npmConfigPrefix}/bin:$PATH"`);
-          logger.info("");
-          logger.info("3. Reload shell configuration:");
-          logger.info("   source ~/.zshrc");
-          logger.info("");
-          logger.info("\u{1F4DA} Alternative Solutions:");
-          logger.info("");
-          logger.info("Option A: Use NVM (Node Version Manager)");
-          logger.info("   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash");
-          logger.info("   nvm install --lts");
-          logger.info("");
-          logger.info("Option B: Fix system directory permissions (requires sudo)");
-          logger.info("   sudo chown -R $(whoami) /usr/local/lib/node_modules");
-          logger.info("");
-          logger.info("Option C: Use sudo (not recommended for security reasons)");
-          logger.info(`   sudo npm install -g @empjs/skill --registry=${registry}`);
-          logger.info("");
-          logger.info("After fixing, try again:");
-          logger.info(`   eskill add ${skillNameOrPath}`);
-        } else if (errorMessage.includes("ENOTFOUND") || errorMessage.includes("ECONNREFUSED")) {
-          logger.error(`Network connection error: ${errorMessage}`);
-          logger.info("");
-          logger.info("Please check:");
-          logger.info("  - Your internet connection");
-          logger.info(`  - Registry accessibility: ${registry}`);
-          logger.info(
-            `  - Try a different registry: eskill add ${skillNameOrPath} --registry=https://registry.npmjs.org/`
-          );
-        } else {
-          logger.error(`Failed to download: ${errorMessage}`);
-          logger.info("");
-          logger.info("If this is a permission error, see the solutions above.");
-          logger.info("For other errors, please check:");
-          logger.info("  - Package name is correct");
-          logger.info("  - Registry is accessible");
-          logger.info(`  - Try: eskill add ${skillNameOrPath} --registry=https://registry.npmjs.org/`);
+      if (step === 0) {
+        logger.info(`
+\u{1F4E6} ${t("foundSkills", { count: availableSkills.length })}`);
+        selectedNames = await promptSkills(availableSkills);
+        step = 1;
+      } else if (step === 1) {
+        if (options.global || options.local) {
+          step = 2;
+          continue;
+        }
+        installScope = await promptSelect(t("selectScope"), [{ name: "global", message: t("globalScope") }, { name: "local", message: t("localScope") }]);
+        if (installScope === "back") {
+          step = availableSkills.length === 1 ? -1 : 0;
+          continue;
+        }
+        step = 2;
+      } else if (step === 2) {
+        if (options.link || options.copy) {
+          step = 3;
+          continue;
         }
-        process.exit(1);
+        installMethod = await promptSelect(t("selectMethod"), [{ name: "link", message: t("linkMethod") }, { name: "copy", message: t("copyMethod") }]);
+        if (installMethod === "back") {
+          step = 1;
+          continue;
+        }
+        step = 3;
       }
-      skillPath = import_node_path5.default.join(tempDir, "node_modules", skillNameOrPath);
-      if (!import_node_fs6.default.existsSync(skillPath)) {
-        logger.error(`Failed to download package: ${skillNameOrPath}`);
-        process.exit(1);
+    } catch (e) {
+      if (step === 0 || step === -1) {
+        logger.warn("\nInstallation cancelled.");
+        process.exit(0);
       }
-    } catch (error) {
-      logger.error(`Failed to download: ${error.message}`);
-      process.exit(1);
-    }
-  }
-  const targetPath = getSharedSkillPath(skillName);
-  const sourceIsTarget = import_node_path5.default.resolve(skillPath) === import_node_path5.default.resolve(targetPath);
-  const alreadyExists = import_node_fs6.default.existsSync(targetPath) && !sourceIsTarget;
-  if (alreadyExists) {
-    if (options.force) {
-      logger.warn("Removing existing installation...");
-      import_node_fs6.default.rmSync(targetPath, { recursive: true, force: true });
-    } else {
-      logger.info(`Skill already exists, updating agent links...`);
+      step--;
+      continue;
     }
   }
-  if (sourceIsTarget) {
-    logger.info(`Skill already in shared directory, updating agent links...`);
-  } else if (alreadyExists && !options.force) {
-  } else if (options.link) {
-    import_node_fs6.default.symlinkSync(skillPath, targetPath, "dir");
-    logger.success(`Linked to shared directory (dev mode)`);
-  } else {
-    copyDir2(skillPath, targetPath);
-    logger.success(`Installed to shared directory`);
-  }
-  logger.info(`\u{1F4CD} Location: ${targetPath}`);
+  options.local = installScope === "local";
+  options.global = installScope === "global";
+  options.copy = installMethod === "copy";
+  options.link = installMethod === "link";
+  const selectedSkills = selectedNames.map((n) => availableSkills.find((s) => s.name === n)).filter(Boolean);
   const cwd = process.cwd();
-  const installedAgents = detectInstalledAgents(cwd);
-  if (installedAgents.length === 0) {
-    logger.warn("No AI agents detected");
-    logger.info("Skill installed to shared directory, but not linked to any agent");
-    logger.info("");
-    logger.info("Supported agents:");
-    logger.info("  AMP, Antigravity, Claude Code, ClawdBot, Cline, Codex, Cursor, Droid,");
-    logger.info("  Gemini, GitHub Copilot, Goose, Kilo, Kiro CLI, OpenCode, Roo, Trae, Windsurf");
-    logger.info("");
-    logger.info('Run "eskill agents" to see all agent directories');
-    return;
+  let agents2 = detectInstalledAgents(cwd);
+  if (options.local) {
+    agents2 = agents2.map((a) => ({ ...a, skillsDirs: (c) => (typeof a.skillsDirs === "function" ? a.skillsDirs(c) : []).filter((d) => d.includes(c || cwd)) })).filter((a) => (typeof a.skillsDirs === "function" ? a.skillsDirs(cwd) : []).length > 0);
   }
-  let targetAgents = installedAgents;
-  if (options.agent && options.agent !== "all") {
-    const agent = AGENTS.find((a) => a.name === options.agent && a.enabled);
-    if (!agent) {
-      logger.error(`Unknown agent: ${options.agent}`);
-      logger.info(`
-Supported agents: ${AGENTS.filter((a) => a.enabled).map((a) => a.name).join(", ")}`);
-      process.exit(1);
-    }
-    targetAgents = [agent];
-    if (!installedAgents.find((a) => a.name === options.agent)) {
-      logger.info(`Note: ${agent.displayName} directory will be created if not exists`);
-    }
+  for (const skill of selectedSkills) {
+    logger.info(`
+\u{1F680} ${t("installing", { name: skill.name })}`);
+    await installFromLocalPath(skill.path, skill.name, options, agents2, cwd);
   }
-  logger.info("\nCreating symlinks...");
-  let successCount = 0;
-  for (const agent of targetAgents) {
-    if (createSymlink(skillName, agent, cwd)) {
-      successCount++;
+  logger.info("");
+  logger.success(`\u2705 ${t("success", { count: selectedSkills.length })}`);
+}
+async function installFromLocalPath(skillPath, skillName, options, installedAgents, cwd) {
+  const targetPath = getSharedSkillPath(skillName);
+  const sourceIsTarget = import_node_path6.default.resolve(skillPath) === import_node_path6.default.resolve(targetPath);
+  if (import_node_fs7.default.existsSync(targetPath) && !sourceIsTarget && options.force) import_node_fs7.default.rmSync(targetPath, { recursive: true, force: true });
+  if (!sourceIsTarget && (!import_node_fs7.default.existsSync(targetPath) || options.force)) {
+    if (options.copy) copyDir2(skillPath, targetPath);
+    else {
+      try {
+        import_node_fs7.default.symlinkSync(skillPath, targetPath, "dir");
+      } catch {
+        copyDir2(skillPath, targetPath);
+      }
     }
   }
-  logger.info("");
-  logger.success(`\u2705 Skill installed successfully!`);
-  logger.info(`
-Linked to ${successCount}/${targetAgents.length} agents`);
-  if (options.link) {
-    logger.info("\n\u{1F4A1} Dev mode: changes to source files will reflect immediately");
+  let targets = installedAgents;
+  if (options.agent && options.agent !== "all") {
+    const a = AGENTS.find((a2) => a2.name === options.agent && a2.enabled);
+    if (a) targets = [a];
+  }
+  if (targets.length > 0) {
+    let count = 0;
+    for (const a of targets) if (createSymlink(skillName, a, cwd, options.copy || a.useCopyInsteadOfSymlink)) count++;
+    logger.dim(`${skillName} -> ${count} agent(s)`);
   }
 }
 function copyDir2(src, dest) {
-  import_node_fs6.default.mkdirSync(dest, { recursive: true });
-  const entries = import_node_fs6.default.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = import_node_path5.default.join(src, entry.name);
-    const destPath = import_node_path5.default.join(dest, entry.name);
-    if (entry.name === "node_modules" || entry.name.startsWith(".")) {
-      continue;
-    }
-    if (entry.isDirectory()) {
-      copyDir2(srcPath, destPath);
-    } else {
-      import_node_fs6.default.copyFileSync(srcPath, destPath);
-    }
+  import_node_fs7.default.mkdirSync(dest, { recursive: true });
+  for (const e of import_node_fs7.default.readdirSync(src, { withFileTypes: true })) {
+    if (e.name === "node_modules" || e.name.startsWith(".")) continue;
+    const s = import_node_path6.default.join(src, e.name);
+    const d = import_node_path6.default.join(dest, e.name);
+    if (e.isDirectory()) copyDir2(s, d);
+    else import_node_fs7.default.copyFileSync(s, d);
   }
 }
 
 // src/commands/list.ts
-var import_node_fs7 = __toESM(require("fs"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
-var import_chalk3 = __toESM(require("chalk"), 1);
+var import_node_fs8 = __toESM(require("fs"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+var import_node_os4 = __toESM(require("os"), 1);
+var import_chalk4 = __toESM(require("chalk"), 1);
+function shortenPath(p) {
+  const home = import_node_os4.default.homedir();
+  return p.startsWith(home) ? p.replace(home, "~") : p;
+}
 function list() {
-  if (!import_node_fs7.default.existsSync(SHARED_SKILLS_DIR)) {
+  if (!import_node_fs8.default.existsSync(SHARED_SKILLS_DIR)) {
     logger.info("No skills installed");
     logger.info(`
-To install a skill, run: ${import_chalk3.default.cyan("eskill install <skill-name>")}`);
+To install a skill, run: ${import_chalk4.default.cyan("eskill install <skill-name>")}`);
     return;
   }
-  const skills = import_node_fs7.default.readdirSync(SHARED_SKILLS_DIR);
+  const skills = import_node_fs8.default.readdirSync(SHARED_SKILLS_DIR).filter((s) => !s.startsWith("."));
   if (skills.length === 0) {
     logger.info("No skills installed");
     logger.info(`
-To install a skill, run: ${import_chalk3.default.cyan("eskill install <skill-name>")}`);
+To install a skill, run: ${import_chalk4.default.cyan("eskill install <skill-name>")}`);
     return;
   }
-  console.log(import_chalk3.default.bold(`
-Installed skills in ${SHARED_SKILLS_DIR}:
+  console.log(import_chalk4.default.bold(`
+\u{1F4E6} Installed Skills in ${import_chalk4.default.blue(shortenPath(SHARED_SKILLS_DIR))}:
 `));
   for (const skill of skills) {
-    const skillPath = import_node_path6.default.join(SHARED_SKILLS_DIR, skill);
+    const skillPath = import_node_path7.default.join(SHARED_SKILLS_DIR, skill);
     try {
-      const stats = import_node_fs7.default.lstatSync(skillPath);
+      const stats = import_node_fs8.default.lstatSync(skillPath);
       if (!stats.isDirectory() && !stats.isSymbolicLink()) {
         continue;
       }
       let version2 = "unknown";
-      const pkgPath = import_node_path6.default.join(skillPath, "package.json");
-      if (import_node_fs7.default.existsSync(pkgPath)) {
+      let description = "";
+      const pkgPath = import_node_path7.default.join(skillPath, "package.json");
+      if (import_node_fs8.default.existsSync(pkgPath)) {
         try {
-          const pkgContent = import_node_fs7.default.readFileSync(pkgPath, "utf-8");
-          const pkg = JSON.parse(pkgContent);
-          if (pkg.version && typeof pkg.version === "string") {
-            version2 = pkg.version;
-          }
+          const pkg = JSON.parse(import_node_fs8.default.readFileSync(pkgPath, "utf-8"));
+          if (pkg.version) version2 = pkg.version;
+          if (pkg.description) description = pkg.description;
         } catch (error) {
         }
       }
-      if (version2 === "unknown") {
-        const skillMdPath = import_node_path6.default.join(skillPath, "SKILL.md");
-        if (import_node_fs7.default.existsSync(skillMdPath)) {
-          try {
-            const skillMdContent = import_node_fs7.default.readFileSync(skillMdPath, "utf-8");
-            const frontmatterMatch = skillMdContent.match(/^---\s*\n([\s\S]*?)\n---/);
-            if (frontmatterMatch) {
-              const frontmatter = frontmatterMatch[1];
-              const versionMatch = frontmatter.match(/^version:\s*(.+)$/m);
-              if (versionMatch) {
-                version2 = versionMatch[1].trim().replace(/^["']|["']$/g, "");
-              }
-            }
-          } catch (error) {
-          }
-        }
-      }
-      if (version2 === "unknown" && isSymlink(skillPath)) {
-        try {
-          const targetPath = readSymlink(skillPath);
-          if (targetPath) {
-            const targetPkgPath = import_node_path6.default.join(targetPath, "package.json");
-            if (import_node_fs7.default.existsSync(targetPkgPath)) {
-              const pkg = JSON.parse(import_node_fs7.default.readFileSync(targetPkgPath, "utf-8"));
-              if (pkg.version && typeof pkg.version === "string") {
-                version2 = pkg.version;
-              }
-            }
+      if (!description) {
+        const skillMdPath = import_node_path7.default.join(skillPath, "SKILL.md");
+        if (import_node_fs8.default.existsSync(skillMdPath)) {
+          const content = import_node_fs8.default.readFileSync(skillMdPath, "utf-8");
+          const descMatch = content.match(/description:\s*["']?([^"'\n]+)["']?/);
+          if (descMatch) description = descMatch[1];
+          if (version2 === "unknown") {
+            const verMatch = content.match(/version:\s*(.+)$/m);
+            if (verMatch) version2 = verMatch[1].trim().replace(/^["']|["']$/g, "");
           }
-        } catch (error) {
         }
       }
       const isDev = isSymlink(skillPath);
-      const devTag = isDev ? import_chalk3.default.yellow(" (dev)") : "";
-      const versionDisplay = version2 !== "unknown" ? import_chalk3.default.gray(`(v${version2})`) : "";
-      console.log(import_chalk3.default.green("\u{1F4E6}") + ` ${import_chalk3.default.bold(skill)}${versionDisplay ? " " + versionDisplay : ""}${devTag}`);
+      const typeLabel = isDev ? import_chalk4.default.bgYellow.black(" DEV LINK ") : import_chalk4.default.bgBlue.white(" INSTALLED ");
+      const versionDisplay = version2 !== "unknown" ? import_chalk4.default.gray(`v${version2}`) : "";
+      const descDisplay = description ? import_chalk4.default.dim(` - ${description}`) : "";
+      console.log(`${import_chalk4.default.green("\u25CF")} ${import_chalk4.default.bold(skill)} ${versionDisplay} ${typeLabel}${descDisplay}`);
       const cwd = process.cwd();
       const linkedAgents = [];
       for (const agent of AGENTS) {
         const skillsDirs = getAgentSkillsDirs(agent, cwd);
         const hasRef = skillsDirs.some((dir) => {
-          const agentSkillPath = import_node_path6.default.join(dir, skill);
-          if (!import_node_fs7.default.existsSync(agentSkillPath)) return false;
+          const agentSkillPath = import_node_path7.default.join(dir, skill);
+          if (!import_node_fs8.default.existsSync(agentSkillPath)) return false;
           if (isSymlink(agentSkillPath)) {
             const target = readSymlink(agentSkillPath);
             return target === skillPath;
           }
           if (agent.useCopyInsteadOfSymlink) {
-            return import_node_fs7.default.statSync(agentSkillPath).isDirectory();
+            return import_node_fs8.default.statSync(agentSkillPath).isDirectory();
           }
           return false;
         });
-        if (hasRef) {
-          linkedAgents.push(agent.displayName);
-        }
+        if (hasRef) linkedAgents.push(agent.displayName);
       }
       if (linkedAgents.length > 0) {
-        console.log(import_chalk3.default.gray(`   \u2192 Linked to: ${linkedAgents.join(", ")}`));
+        console.log(import_chalk4.default.gray(`  \u{1F517} Linked to: ${import_chalk4.default.white(linkedAgents.join(", "))}`));
       } else {
-        console.log(import_chalk3.default.yellow(`   \u2192 Not linked to any agent`));
+        console.log(import_chalk4.default.red(`  \u26A0\uFE0F Not linked to any agent`));
       }
       if (isDev) {
         const target = readSymlink(skillPath);
         if (target) {
-          console.log(import_chalk3.default.gray(`   \u2192 Source: ${target}`));
+          console.log(import_chalk4.default.gray(`  \u{1F4C1} Source: ${import_chalk4.default.dim(shortenPath(target))}`));
         }
       }
       console.log("");
@@ -1053,11 +1068,11 @@ Installed skills in ${SHARED_SKILLS_DIR}:
 }
 
 // src/commands/remove.ts
-var import_node_fs8 = __toESM(require("fs"), 1);
+var import_node_fs9 = __toESM(require("fs"), 1);
 async function remove(skillName, options = {}) {
   const extractedName = extractSkillName(skillName);
   const sharedPath = getSharedSkillPath(extractedName);
-  const skillExists = import_node_fs8.default.existsSync(sharedPath);
+  const skillExists = import_node_fs9.default.existsSync(sharedPath);
   if (!skillExists) {
     logger.error(`Skill not found: ${extractedName}`);
     logger.info(`Location: ${sharedPath}`);
@@ -1093,12 +1108,12 @@ Supported agents: ${AGENTS.filter((a) => a.enabled).map((a) => a.name).join(", "
   }
   logger.info("Removing skill from shared directory...");
   try {
-    const stats = import_node_fs8.default.lstatSync(sharedPath);
+    const stats = import_node_fs9.default.lstatSync(sharedPath);
     if (stats.isSymbolicLink()) {
-      import_node_fs8.default.unlinkSync(sharedPath);
+      import_node_fs9.default.unlinkSync(sharedPath);
       logger.success("Removed symlink from shared directory");
     } else {
-      import_node_fs8.default.rmSync(sharedPath, { recursive: true, force: true });
+      import_node_fs9.default.rmSync(sharedPath, { recursive: true, force: true });
       logger.success("Removed skill from shared directory");
     }
   } catch (error) {
@@ -1108,7 +1123,7 @@ Supported agents: ${AGENTS.filter((a) => a.enabled).map((a) => a.name).join(", "
   const remainingRefs = [];
   for (const agent of AGENTS) {
     const agentSkillPaths = getAgentSkillPaths(agent.name, extractedName, cwd);
-    const hasRef = agentSkillPaths.some((p) => import_node_fs8.default.existsSync(p));
+    const hasRef = agentSkillPaths.some((p) => import_node_fs9.default.existsSync(p));
     if (hasRef) {
       remainingRefs.push(agent.displayName);
     }
@@ -1125,6 +1140,56 @@ Supported agents: ${AGENTS.filter((a) => a.enabled).map((a) => a.name).join(", "
   }
 }
 
+// src/commands/auth.ts
+var import_enquirer2 = __toESM(require("enquirer"), 1);
+var { Input, Password: Password2 } = import_enquirer2.default;
+async function auth(domain, options = {}) {
+  if (options.list) {
+    const config = loadConfig();
+    if (Object.keys(config.tokens).length === 0) {
+      logger.info("No tokens configured.");
+      return;
+    }
+    logger.info("\n\u{1F510} Configured Tokens:");
+    for (const [dom, token] of Object.entries(config.tokens)) {
+      const masked = token.substring(0, 4) + "*".repeat(token.length - 8) + token.substring(token.length - 4);
+      logger.info(`  - ${dom}: ${masked}`);
+    }
+    return;
+  }
+  if (options.remove) {
+    const config = loadConfig();
+    if (config.tokens[options.remove]) {
+      delete config.tokens[options.remove];
+      saveToken(options.remove, "");
+      logger.success(`Removed token for ${options.remove}`);
+    } else {
+      logger.error(`No token found for ${options.remove}`);
+    }
+    return;
+  }
+  let targetDomain = domain;
+  let targetToken = options.token;
+  if (!targetDomain) {
+    const prompt = new Input({
+      message: "Enter the domain (e.g., git.internal.corp):",
+      validate: (value) => value.length > 0
+    });
+    targetDomain = await prompt.run();
+  }
+  if (!targetToken) {
+    const prompt = new Password2({
+      message: `Enter Access Token for ${targetDomain}:`,
+      validate: (value) => value.length > 0
+    });
+    targetToken = await prompt.run();
+  }
+  if (targetDomain && targetToken) {
+    saveToken(targetDomain, targetToken);
+    logger.success(`Token saved for ${targetDomain}`);
+  }
+}
+
 // src/index.ts
 var __filename2 = (0, import_url.fileURLToPath)(importMetaUrl);
 var __dirname = (0, import_path.dirname)(__filename2);
@@ -1133,7 +1198,7 @@ var packageJson = JSON.parse((0, import_fs.readFileSync)(packageJsonPath, "utf-8
 var version = packageJson.version;
 var program = new import_commander.Command();
 program.name("eskill").description("Unified CLI tool for managing AI agent skills").version(version);
-program.command("install <skill>").alias("add").description("Install a skill from NPM, Git URL, or local directory").option("-a, --agent <name>", "Install for specific agent (claude, cursor, windsurf, or all)").option("-l, --link", "Dev mode: symlink from local directory").option("-f, --force", "Force reinstall if already exists").option("-r, --registry <url>", "NPM registry URL (overrides .npmrc and global config)").option(
+program.command("install <skill>").alias("add").description("Install a skill (Supports selective install, local/global scope, and link/copy methods)").option("-a, --agent <name>", "Install for specific agent (claude, cursor, etc.)").option("--all", "Install all skills if multiple are found in a collection").option("--global", "Install to global agent directories (default)").option("--local", "Install to current project directory (.agent/skills)").option("--link", "Use symlink for installation (changes reflect instantly)").option("--copy", "Use full copy for installation (portable)").option("-f, --force", "Force reinstall if already exists").option("-r, --registry <url>", "NPM registry URL").option(
   "-t, --timeout <ms>",
   "Timeout in milliseconds (default: 180000 for npm, 120000 for git)",
   (value) => Number.parseInt(value, 10)
@@ -1145,6 +1210,14 @@ program.command("install <skill>").alias("add").description("Install a skill fro
     process.exit(1);
   }
 });
+program.command("auth [domain]").description("Manage access tokens for private repositories").option("-t, --token <token>", "Access token").option("-l, --list", "List all saved tokens").option("-r, --remove <domain>", "Remove token for a domain").action(async (domain, options) => {
+  try {
+    await auth(domain, options);
+  } catch (error) {
+    console.error("Error:", error.message);
+    process.exit(1);
+  }
+});
 program.command("list").alias("ls").description("List installed skills").action(() => {
   try {
     list();