@empjs/skill 1.0.6 → 1.0.8

package/dist/index.js

@@ -7,14 +7,16 @@ import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/agents.ts
-import fs from "fs";
+import fs2 from "fs";
 import os2 from "os";
 import chalk from "chalk";
 
 // src/config/agents.ts
+import fs from "fs";
 import os from "os";
 import path from "path";
 var HOME = os.homedir();
+var CONFIG_HOME = process.env.XDG_CONFIG_HOME || path.join(HOME, ".config");
 function getAgentSkillsDirs(agent, cwd) {
   if (agent.skillsDirs) {
     if (typeof agent.skillsDirs === "function") {
@@ -29,21 +31,44 @@ function getAgentSkillsDirs(agent, cwd) {
 }
 var AGENTS = [
   {
-    name: "claude",
-    displayName: "Claude Code",
-    skillsDir: path.join(HOME, ".claude", "skills"),
+    name: "amp",
+    displayName: "AMP",
+    skillsDirs: (cwd) => {
+      const dirs = [path.join(CONFIG_HOME, "agents", "skills")];
+      if (cwd) dirs.push(path.join(cwd, ".agents", "skills"));
+      return dirs;
+    },
     enabled: true
   },
   {
-    name: "cursor",
-    displayName: "Cursor",
-    skillsDir: path.join(HOME, ".cursor", "skills"),
+    name: "antigravity",
+    displayName: "Antigravity",
+    skillsDirs: (cwd) => {
+      const dirs = [path.join(HOME, ".gemini", "antigravity", "skills")];
+      if (cwd) dirs.push(path.join(cwd, ".agent", "skills"));
+      if (cwd) dirs.push(path.join(cwd, ".shared", "skills"));
+      return dirs;
+    },
     enabled: true
   },
   {
-    name: "windsurf",
-    displayName: "Windsurf",
-    skillsDir: path.join(HOME, ".windsurf", "skills"),
+    name: "claude",
+    displayName: "Claude Code",
+    skillsDir: path.join(process.env.CLAUDE_CONFIG_DIR?.trim() || path.join(HOME, ".claude"), "skills"),
+    enabled: true
+  },
+  {
+    name: "clawdbot",
+    displayName: "ClawdBot",
+    skillsDirs: () => {
+      const openclaw = path.join(HOME, ".openclaw", "skills");
+      const clawdbot = path.join(HOME, ".clawdbot", "skills");
+      const moltbot = path.join(HOME, ".moltbot", "skills");
+      if (fs.existsSync(path.join(HOME, ".openclaw"))) return [openclaw];
+      if (fs.existsSync(path.join(HOME, ".clawdbot"))) return [clawdbot];
+      if (fs.existsSync(path.join(HOME, ".moltbot"))) return [moltbot];
+      return [openclaw];
+    },
     enabled: true
   },
   {
@@ -52,9 +77,29 @@ var AGENTS = [
     skillsDir: path.join(HOME, ".cline", "skills"),
     enabled: true
   },
+  {
+    name: "codex",
+    displayName: "Codex",
+    skillsDir: path.join(process.env.CODEX_HOME?.trim() || path.join(HOME, ".codex"), "skills"),
+    enabled: true
+  },
+  {
+    name: "cursor",
+    displayName: "Cursor",
+    skillsDir: path.join(HOME, ".cursor", "skills"),
+    enabled: true,
+    /** Cursor does not follow symlinks to discover skills (known bug). Use copy instead. */
+    useCopyInsteadOfSymlink: true
+  },
+  {
+    name: "droid",
+    displayName: "Droid",
+    skillsDir: path.join(HOME, ".factory", "skills"),
+    enabled: true
+  },
   {
     name: "gemini",
-    displayName: "Gemini Code",
+    displayName: "Gemini",
     skillsDir: path.join(HOME, ".gemini", "skills"),
     enabled: true
   },
@@ -65,47 +110,31 @@ var AGENTS = [
     enabled: true
   },
   {
-    name: "opencode",
-    displayName: "OpenCode",
-    skillsDir: path.join(HOME, ".opencode", "skills"),
+    name: "goose",
+    displayName: "Goose",
+    skillsDir: path.join(CONFIG_HOME, "goose", "skills"),
     enabled: true
   },
   {
-    name: "antigravity",
-    displayName: "Antigravity",
-    skillsDirs: (cwd) => {
-      const dirs = [];
-      dirs.push(path.join(HOME, ".gemini", "antigravity", "skills"));
-      if (cwd) {
-        dirs.push(path.join(cwd, ".agent", "skills"));
-      }
-      if (cwd) {
-        dirs.push(path.join(cwd, ".shared", "skills"));
-      }
-      return dirs;
-    },
+    name: "kilo",
+    displayName: "Kilo Code",
+    skillsDir: path.join(HOME, ".kilocode", "skills"),
     enabled: true
   },
   {
     name: "kiro",
-    displayName: "Kiro",
+    displayName: "Kiro CLI",
     skillsDir: path.join(HOME, ".kiro", "skills"),
     enabled: true
   },
   {
-    name: "codex",
-    displayName: "Codex CLI",
-    skillsDir: path.join(HOME, ".codex", "skills"),
-    enabled: true
-  },
-  {
-    name: "qoder",
-    displayName: "Qoder",
-    skillsDir: path.join(HOME, ".qoder", "skills"),
+    name: "opencode",
+    displayName: "OpenCode",
+    skillsDir: path.join(CONFIG_HOME, "opencode", "skills"),
     enabled: true
   },
   {
-    name: "roocode",
+    name: "roo",
     displayName: "Roo Code",
     skillsDir: path.join(HOME, ".roo", "skills"),
     enabled: true
@@ -116,6 +145,24 @@ var AGENTS = [
     skillsDir: path.join(HOME, ".trae", "skills"),
     enabled: true
   },
+  {
+    name: "windsurf",
+    displayName: "Windsurf",
+    skillsDirs: () => {
+      const dirs = [];
+      dirs.push(path.join(HOME, ".windsurf", "skills"));
+      dirs.push(path.join(HOME, ".codeium", "windsurf", "skills"));
+      return dirs;
+    },
+    enabled: true
+  },
+  // Additional agents
+  {
+    name: "qoder",
+    displayName: "Qoder",
+    skillsDir: path.join(HOME, ".qoder", "skills"),
+    enabled: true
+  },
   {
     name: "continue",
     displayName: "Continue",
@@ -141,7 +188,7 @@ function agents() {
     } else {
       console.log(chalk.gray(`  Directories${dirsInfo}:`));
       for (const dir of skillsDirs) {
-        const exists = fs.existsSync(dir);
+        const exists = fs2.existsSync(dir);
         const status = exists ? chalk.green("\u2713") : chalk.gray("\u25CB");
         const pathColor = exists ? chalk.white : chalk.gray;
         console.log(`    ${status} ${pathColor(dir)}`);
@@ -150,7 +197,7 @@ function agents() {
     console.log("");
   }
   console.log(chalk.bold("\u{1F4E6} Shared Skills Directory:"));
-  const sharedExists = fs.existsSync(SHARED_SKILLS_DIR);
+  const sharedExists = fs2.existsSync(SHARED_SKILLS_DIR);
   const sharedStatus = sharedExists ? chalk.green("\u2713") : chalk.gray("\u25CB");
   const sharedPathColor = sharedExists ? chalk.white : chalk.gray;
   console.log(`  ${sharedStatus} ${sharedPathColor(SHARED_SKILLS_DIR)}`);
@@ -164,7 +211,7 @@ function agents() {
 
 // src/commands/install.ts
 import { exec as exec2 } from "child_process";
-import fs5 from "fs";
+import fs6 from "fs";
 import os3 from "os";
 import path5 from "path";
 import { promisify as promisify2 } from "util";
@@ -296,6 +343,10 @@ var Logger = class {
     if (this.spinner) this.spinner.stop();
     console.log(chalk2.red("\u2717"), message);
   }
+  dim(message) {
+    if (this.spinner) this.spinner.stop();
+    console.log(chalk2.dim("  " + message));
+  }
   start(message) {
     if (this.spinner) this.spinner.stop();
     this.spinner = ora(message).start();
@@ -332,7 +383,7 @@ var Logger = class {
 var logger = new Logger();
 
 // src/utils/paths.ts
-import fs2 from "fs";
+import fs3 from "fs";
 import path2 from "path";
 function getSharedSkillPath(skillName) {
   return path2.join(SHARED_SKILLS_DIR, skillName);
@@ -346,8 +397,8 @@ function getAgentSkillPaths(agentName, skillName, cwd) {
   return skillsDirs.map((dir) => path2.join(dir, skillName));
 }
 function ensureSharedDir() {
-  if (!fs2.existsSync(SHARED_SKILLS_DIR)) {
-    fs2.mkdirSync(SHARED_SKILLS_DIR, { recursive: true });
+  if (!fs3.existsSync(SHARED_SKILLS_DIR)) {
+    fs3.mkdirSync(SHARED_SKILLS_DIR, { recursive: true });
   }
 }
 function detectInstalledAgents(cwd) {
@@ -355,7 +406,7 @@ function detectInstalledAgents(cwd) {
     try {
       const skillsDirs = getAgentSkillsDirs(agent, cwd);
       return skillsDirs.some((dir) => {
-        return fs2.existsSync(dir) || fs2.existsSync(path2.dirname(dir));
+        return fs3.existsSync(dir) || fs3.existsSync(path2.dirname(dir));
       });
     } catch {
       return false;
@@ -376,7 +427,7 @@ function extractSkillName(nameOrPath) {
 
 // src/utils/registry.ts
 import { exec } from "child_process";
-import fs3 from "fs";
+import fs4 from "fs";
 import path3 from "path";
 import { promisify } from "util";
 var execAsync = promisify(exec);
@@ -384,7 +435,7 @@ function findNpmrc(startDir) {
   let currentDir = path3.resolve(startDir);
   while (currentDir !== path3.dirname(currentDir)) {
     const npmrcPath = path3.join(currentDir, ".npmrc");
-    if (fs3.existsSync(npmrcPath)) {
+    if (fs4.existsSync(npmrcPath)) {
       return npmrcPath;
     }
     currentDir = path3.dirname(currentDir);
@@ -393,7 +444,7 @@ function findNpmrc(startDir) {
 }
 function parseNpmrc(npmrcPath) {
   try {
-    const content = fs3.readFileSync(npmrcPath, "utf-8");
+    const content = fs4.readFileSync(npmrcPath, "utf-8");
     const lines = content.split("\n");
     for (const line of lines) {
       const trimmed = line.trim();
@@ -436,33 +487,50 @@ async function getRegistry(cwd = process.cwd()) {
 }
 
 // src/utils/symlink.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import path4 from "path";
+function copyDir(src, dest) {
+  fs5.mkdirSync(dest, { recursive: true });
+  const entries = fs5.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+    const srcPath = path4.join(src, entry.name);
+    const destPath = path4.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs5.copyFileSync(srcPath, destPath);
+    }
+  }
+}
 function createSymlink(skillName, agent, cwd) {
   const source = getSharedSkillPath(skillName);
-  if (!fs4.existsSync(source)) {
+  if (!fs5.existsSync(source)) {
     logger.error(`Skill not found: ${source}`);
     return false;
   }
   const targets = getAgentSkillPaths(agent.name, skillName, cwd);
+  const useCopy = agent.useCopyInsteadOfSymlink === true;
   let successCount = 0;
   for (const target of targets) {
     const targetDir = path4.dirname(target);
-    if (!fs4.existsSync(targetDir)) {
+    if (!fs5.existsSync(targetDir)) {
       try {
-        fs4.mkdirSync(targetDir, { recursive: true });
+        fs5.mkdirSync(targetDir, { recursive: true });
       } catch (error) {
         logger.error(`Failed to create directory ${targetDir}: ${error.message}`);
         continue;
       }
     }
-    if (fs4.existsSync(target)) {
+    if (fs5.existsSync(target)) {
       try {
-        const stats = fs4.lstatSync(target);
+        const stats = fs5.lstatSync(target);
         if (stats.isSymbolicLink()) {
-          fs4.unlinkSync(target);
+          fs5.unlinkSync(target);
+        } else if (stats.isDirectory()) {
+          fs5.rmSync(target, { recursive: true, force: true });
         } else {
-          logger.warn(`Target exists but is not a symlink, skipping: ${target}`);
+          logger.warn(`Target exists but is not a symlink/dir, skipping: ${target}`);
           continue;
         }
       } catch (error) {
@@ -471,10 +539,14 @@ function createSymlink(skillName, agent, cwd) {
       }
     }
     try {
-      fs4.symlinkSync(source, target, "dir");
+      if (useCopy) {
+        copyDir(source, target);
+      } else {
+        fs5.symlinkSync(source, target, "dir");
+      }
       successCount++;
     } catch (error) {
-      logger.error(`Failed to create symlink at ${target}: ${error.message}`);
+      logger.error(`Failed to ${useCopy ? "copy" : "symlink"} at ${target}: ${error.message}`);
     }
   }
   if (successCount > 0) {
@@ -488,19 +560,22 @@ function removeSymlink(skillName, agent, cwd) {
   const targets = getAgentSkillPaths(agent.name, skillName, cwd);
   let removedCount = 0;
   for (const target of targets) {
-    if (!fs4.existsSync(target)) {
+    if (!fs5.existsSync(target)) {
       continue;
     }
     try {
-      const stats = fs4.lstatSync(target);
+      const stats = fs5.lstatSync(target);
       if (stats.isSymbolicLink()) {
-        fs4.unlinkSync(target);
+        fs5.unlinkSync(target);
+        removedCount++;
+      } else if (stats.isDirectory()) {
+        fs5.rmSync(target, { recursive: true, force: true });
         removedCount++;
       } else {
-        logger.warn(`Not a symlink: ${target}`);
+        logger.warn(`Not a symlink or directory: ${target}`);
       }
     } catch (error) {
-      logger.error(`Failed to remove symlink at ${target}: ${error.message}`);
+      logger.error(`Failed to remove at ${target}: ${error.message}`);
     }
   }
   if (removedCount > 0) {
@@ -512,7 +587,7 @@ function removeSymlink(skillName, agent, cwd) {
 }
 function isSymlink(filePath) {
   try {
-    const stats = fs4.lstatSync(filePath);
+    const stats = fs5.lstatSync(filePath);
     return stats.isSymbolicLink();
   } catch {
     return false;
@@ -520,7 +595,7 @@ function isSymlink(filePath) {
 }
 function readSymlink(filePath) {
   try {
-    return fs4.readlinkSync(filePath);
+    return fs5.readlinkSync(filePath);
   } catch {
     return null;
   }
@@ -550,11 +625,20 @@ async function execWithTimeout(command, timeout = 12e4, env) {
   }
 }
 async function install(skillNameOrPath, options = {}) {
-  logger.info(`Installing skill: ${skillNameOrPath}`);
+  const isGit = isGitUrl(skillNameOrPath);
+  if (isGit) {
+    logger.info("Installing from Git URL");
+    logger.dim(skillNameOrPath);
+  } else {
+    logger.info(`Installing skill: ${skillNameOrPath}`);
+  }
   ensureSharedDir();
   let skillPath;
   let skillName;
-  if (isGitUrl(skillNameOrPath)) {
+  if (process.env.DEBUG_ESKILL) {
+    logger.dim(`[DEBUG] isGitUrl=${isGit}, parseGitUrl=${parseGitUrl(skillNameOrPath) ? "ok" : "null"}`);
+  }
+  if (isGit) {
     const gitInfo = parseGitUrl(skillNameOrPath);
     if (!gitInfo) {
       logger.error(`Invalid git URL: ${skillNameOrPath}`);
@@ -566,21 +650,17 @@ async function install(skillNameOrPath, options = {}) {
     const cloneDir = path5.join(tempDir, "repo");
     try {
       const timeout = options.timeout || 12e4;
-      const spinner = logger.start(`Cloning ${gitInfo.gitUrl}...`);
-      logger.infoWithoutStop(`Repository: ${gitInfo.gitUrl}`);
-      if (gitInfo.branch) {
-        logger.infoWithoutStop(`Branch: ${gitInfo.branch}`);
-      }
-      if (gitInfo.path) {
-        logger.infoWithoutStop(`Path: ${gitInfo.path}`);
-      }
-      logger.infoWithoutStop(`Timeout: ${timeout / 1e3}s`);
-      fs5.mkdirSync(tempDir, { recursive: true });
+      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...`);
+      fs6.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`;
       try {
         await execWithTimeout(cloneCommand, timeout);
-        spinner.succeed(`Repository cloned successfully`);
+        spinner.succeed(`Cloned successfully`);
       } catch (error) {
         spinner.fail("Clone failed");
         if (error.message.includes("timeout")) {
@@ -597,7 +677,7 @@ async function install(skillNameOrPath, options = {}) {
       }
       if (gitInfo.path) {
         skillPath = path5.join(cloneDir, gitInfo.path);
-        if (!fs5.existsSync(skillPath)) {
+        if (!fs6.existsSync(skillPath)) {
           logger.error(`Path not found in repository: ${gitInfo.path}`);
           logger.info(`Repository cloned to: ${cloneDir}`);
           process.exit(1);
@@ -606,7 +686,7 @@ async function install(skillNameOrPath, options = {}) {
         skillPath = cloneDir;
       }
       const skillMdPath = path5.join(skillPath, "SKILL.md");
-      if (!fs5.existsSync(skillMdPath)) {
+      if (!fs6.existsSync(skillMdPath)) {
         logger.warn(`Warning: SKILL.md not found in ${skillPath}`);
         logger.info("The directory may not be a valid skill package");
       }
@@ -628,16 +708,16 @@ Tried to clone: ${gitInfo.gitUrl}`);
       }
       process.exit(1);
     }
-  } else if (options.link || fs5.existsSync(skillNameOrPath)) {
+  } else if (options.link || fs6.existsSync(skillNameOrPath)) {
     skillPath = path5.resolve(skillNameOrPath);
-    if (!fs5.existsSync(skillPath)) {
+    if (!fs6.existsSync(skillPath)) {
       logger.error(`Path not found: ${skillPath}`);
       process.exit(1);
     }
     const pkgPath = path5.join(skillPath, "package.json");
-    if (fs5.existsSync(pkgPath)) {
+    if (fs6.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
         skillName = extractSkillName(pkg.name);
       } catch {
         skillName = extractSkillName(path5.basename(skillPath));
@@ -654,12 +734,12 @@ Tried to clone: ${gitInfo.gitUrl}`);
       const spinner = logger.start(`Installing ${skillNameOrPath}...`);
       logger.infoWithoutStop(`Registry: ${registry}`);
       logger.infoWithoutStop(`Timeout: ${timeout / 1e3}s`);
-      fs5.mkdirSync(tempDir, { recursive: true });
+      fs6.mkdirSync(tempDir, { recursive: true });
       logger.updateSpinner(`Downloading ${skillNameOrPath} from ${registry}...`);
       const homeDir = process.env.HOME || process.env.USERPROFILE || os3.homedir();
       const npmCacheDir = path5.join(homeDir, ".npm");
       const npmConfigPrefix = path5.join(homeDir, ".npm-global");
-      fs5.mkdirSync(npmCacheDir, { recursive: true });
+      fs6.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,
@@ -740,7 +820,7 @@ Tried to clone: ${gitInfo.gitUrl}`);
         process.exit(1);
       }
       skillPath = path5.join(tempDir, "node_modules", skillNameOrPath);
-      if (!fs5.existsSync(skillPath)) {
+      if (!fs6.existsSync(skillPath)) {
         logger.error(`Failed to download package: ${skillNameOrPath}`);
         process.exit(1);
       }
@@ -750,21 +830,24 @@ Tried to clone: ${gitInfo.gitUrl}`);
     }
   }
   const targetPath = getSharedSkillPath(skillName);
-  if (fs5.existsSync(targetPath)) {
+  const sourceIsTarget = path5.resolve(skillPath) === path5.resolve(targetPath);
+  const alreadyExists = fs6.existsSync(targetPath) && !sourceIsTarget;
+  if (alreadyExists) {
     if (options.force) {
       logger.warn("Removing existing installation...");
-      fs5.rmSync(targetPath, { recursive: true, force: true });
+      fs6.rmSync(targetPath, { recursive: true, force: true });
     } else {
-      logger.error(`Skill already exists: ${targetPath}`);
-      logger.info("Use --force to overwrite");
-      process.exit(1);
+      logger.info(`Skill already exists, updating agent links...`);
     }
   }
-  if (options.link) {
-    fs5.symlinkSync(skillPath, targetPath, "dir");
+  if (sourceIsTarget) {
+    logger.info(`Skill already in shared directory, updating agent links...`);
+  } else if (alreadyExists && !options.force) {
+  } else if (options.link) {
+    fs6.symlinkSync(skillPath, targetPath, "dir");
     logger.success(`Linked to shared directory (dev mode)`);
   } else {
-    copyDir(skillPath, targetPath);
+    copyDir2(skillPath, targetPath);
     logger.success(`Installed to shared directory`);
   }
   logger.info(`\u{1F4CD} Location: ${targetPath}`);
@@ -775,21 +858,25 @@ Tried to clone: ${gitInfo.gitUrl}`);
     logger.info("Skill installed to shared directory, but not linked to any agent");
     logger.info("");
     logger.info("Supported agents:");
-    logger.info("  - Claude Code (~/.claude/skills)");
-    logger.info("  - Cursor (~/.cursor/skills)");
-    logger.info("  - Windsurf (~/.windsurf/skills)");
+    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 targetAgents = installedAgents;
   if (options.agent && options.agent !== "all") {
-    const agent = installedAgents.find((a) => a.name === options.agent);
+    const agent = AGENTS.find((a) => a.name === options.agent && a.enabled);
     if (!agent) {
-      logger.error(`Agent not installed: ${options.agent}`);
+      logger.error(`Unknown agent: ${options.agent}`);
       logger.info(`
-Installed agents: ${installedAgents.map((a) => a.name).join(", ")}`);
+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`);
+    }
   }
   logger.info("\nCreating symlinks...");
   let successCount = 0;
@@ -806,9 +893,9 @@ Linked to ${successCount}/${targetAgents.length} agents`);
     logger.info("\n\u{1F4A1} Dev mode: changes to source files will reflect immediately");
   }
 }
-function copyDir(src, dest) {
-  fs5.mkdirSync(dest, { recursive: true });
-  const entries = fs5.readdirSync(src, { withFileTypes: true });
+function copyDir2(src, dest) {
+  fs6.mkdirSync(dest, { recursive: true });
+  const entries = fs6.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = path5.join(src, entry.name);
     const destPath = path5.join(dest, entry.name);
@@ -816,25 +903,25 @@ function copyDir(src, dest) {
       continue;
     }
     if (entry.isDirectory()) {
-      copyDir(srcPath, destPath);
+      copyDir2(srcPath, destPath);
     } else {
-      fs5.copyFileSync(srcPath, destPath);
+      fs6.copyFileSync(srcPath, destPath);
     }
   }
 }
 
 // src/commands/list.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import path6 from "path";
 import chalk3 from "chalk";
 function list() {
-  if (!fs6.existsSync(SHARED_SKILLS_DIR)) {
+  if (!fs7.existsSync(SHARED_SKILLS_DIR)) {
     logger.info("No skills installed");
     logger.info(`
 To install a skill, run: ${chalk3.cyan("eskill install <skill-name>")}`);
     return;
   }
-  const skills = fs6.readdirSync(SHARED_SKILLS_DIR);
+  const skills = fs7.readdirSync(SHARED_SKILLS_DIR);
   if (skills.length === 0) {
     logger.info("No skills installed");
     logger.info(`
@@ -847,15 +934,15 @@ Installed skills in ${SHARED_SKILLS_DIR}:
   for (const skill of skills) {
     const skillPath = path6.join(SHARED_SKILLS_DIR, skill);
     try {
-      const stats = fs6.lstatSync(skillPath);
+      const stats = fs7.lstatSync(skillPath);
       if (!stats.isDirectory() && !stats.isSymbolicLink()) {
         continue;
       }
       let version2 = "unknown";
       const pkgPath = path6.join(skillPath, "package.json");
-      if (fs6.existsSync(pkgPath)) {
+      if (fs7.existsSync(pkgPath)) {
         try {
-          const pkgContent = fs6.readFileSync(pkgPath, "utf-8");
+          const pkgContent = fs7.readFileSync(pkgPath, "utf-8");
           const pkg = JSON.parse(pkgContent);
           if (pkg.version && typeof pkg.version === "string") {
             version2 = pkg.version;
@@ -865,9 +952,9 @@ Installed skills in ${SHARED_SKILLS_DIR}:
       }
       if (version2 === "unknown") {
         const skillMdPath = path6.join(skillPath, "SKILL.md");
-        if (fs6.existsSync(skillMdPath)) {
+        if (fs7.existsSync(skillMdPath)) {
           try {
-            const skillMdContent = fs6.readFileSync(skillMdPath, "utf-8");
+            const skillMdContent = fs7.readFileSync(skillMdPath, "utf-8");
             const frontmatterMatch = skillMdContent.match(/^---\s*\n([\s\S]*?)\n---/);
             if (frontmatterMatch) {
               const frontmatter = frontmatterMatch[1];
@@ -885,8 +972,8 @@ Installed skills in ${SHARED_SKILLS_DIR}:
           const targetPath = readSymlink(skillPath);
           if (targetPath) {
             const targetPkgPath = path6.join(targetPath, "package.json");
-            if (fs6.existsSync(targetPkgPath)) {
-              const pkg = JSON.parse(fs6.readFileSync(targetPkgPath, "utf-8"));
+            if (fs7.existsSync(targetPkgPath)) {
+              const pkg = JSON.parse(fs7.readFileSync(targetPkgPath, "utf-8"));
               if (pkg.version && typeof pkg.version === "string") {
                 version2 = pkg.version;
               }
@@ -903,15 +990,19 @@ Installed skills in ${SHARED_SKILLS_DIR}:
       const linkedAgents = [];
       for (const agent of AGENTS) {
         const skillsDirs = getAgentSkillsDirs(agent, cwd);
-        const hasSymlink = skillsDirs.some((dir) => {
+        const hasRef = skillsDirs.some((dir) => {
           const agentSkillPath = path6.join(dir, skill);
-          if (fs6.existsSync(agentSkillPath) && isSymlink(agentSkillPath)) {
+          if (!fs7.existsSync(agentSkillPath)) return false;
+          if (isSymlink(agentSkillPath)) {
             const target = readSymlink(agentSkillPath);
             return target === skillPath;
           }
+          if (agent.useCopyInsteadOfSymlink) {
+            return fs7.statSync(agentSkillPath).isDirectory();
+          }
           return false;
         });
-        if (hasSymlink) {
+        if (hasRef) {
           linkedAgents.push(agent.displayName);
         }
       }
@@ -933,11 +1024,11 @@ Installed skills in ${SHARED_SKILLS_DIR}:
 }
 
 // src/commands/remove.ts
-import fs7 from "fs";
+import fs8 from "fs";
 async function remove(skillName, options = {}) {
   const extractedName = extractSkillName(skillName);
   const sharedPath = getSharedSkillPath(extractedName);
-  const skillExists = fs7.existsSync(sharedPath);
+  const skillExists = fs8.existsSync(sharedPath);
   if (!skillExists) {
     logger.error(`Skill not found: ${extractedName}`);
     logger.info(`Location: ${sharedPath}`);
@@ -947,11 +1038,11 @@ async function remove(skillName, options = {}) {
   const installedAgents = detectInstalledAgents(cwd);
   let targetAgents = installedAgents;
   if (options.agent && options.agent !== "all") {
-    const agent = installedAgents.find((a) => a.name === options.agent);
+    const agent = AGENTS.find((a) => a.name === options.agent && a.enabled);
     if (!agent) {
-      logger.error(`Agent not installed: ${options.agent}`);
+      logger.error(`Unknown agent: ${options.agent}`);
       logger.info(`
-Installed agents: ${installedAgents.map((a) => a.name).join(", ")}`);
+Supported agents: ${AGENTS.filter((a) => a.enabled).map((a) => a.name).join(", ")}`);
       process.exit(1);
     }
     targetAgents = [agent];
@@ -973,35 +1064,33 @@ Installed agents: ${installedAgents.map((a) => a.name).join(", ")}`);
   }
   logger.info("Removing skill from shared directory...");
   try {
-    const stats = fs7.lstatSync(sharedPath);
+    const stats = fs8.lstatSync(sharedPath);
     if (stats.isSymbolicLink()) {
-      fs7.unlinkSync(sharedPath);
+      fs8.unlinkSync(sharedPath);
       logger.success("Removed symlink from shared directory");
     } else {
-      fs7.rmSync(sharedPath, { recursive: true, force: true });
+      fs8.rmSync(sharedPath, { recursive: true, force: true });
       logger.success("Removed skill from shared directory");
     }
   } catch (error) {
     logger.error(`Failed to remove skill: ${error.message}`);
     process.exit(1);
   }
-  const remainingSymlinks = [];
+  const remainingRefs = [];
   for (const agent of AGENTS) {
     const agentSkillPaths = getAgentSkillPaths(agent.name, extractedName, cwd);
-    const hasSymlink = agentSkillPaths.some((path7) => {
-      return fs7.existsSync(path7) && isSymlink(path7);
-    });
-    if (hasSymlink) {
-      remainingSymlinks.push(agent.displayName);
+    const hasRef = agentSkillPaths.some((p) => fs8.existsSync(p));
+    if (hasRef) {
+      remainingRefs.push(agent.displayName);
     }
   }
-  if (remainingSymlinks.length > 0) {
+  if (remainingRefs.length > 0) {
     logger.warn(`
-\u26A0\uFE0F  Warning: Found remaining symlinks in:`);
-    for (const agentName of remainingSymlinks) {
+\u26A0\uFE0F  Warning: Found remaining references in:`);
+    for (const agentName of remainingRefs) {
       logger.info(`  - ${agentName}`);
     }
-    logger.info("\nYou may need to manually remove these symlinks");
+    logger.info("\nYou may need to manually remove these");
   } else {
     logger.success(`\u2705 Skill "${extractedName}" removed successfully!`);
   }