@mcp-s/skills 1.0.2

package/README.md

@@ -0,0 +1,137 @@
+# @mcp-s/skills
+
+Install skills onto coding agents from an MCP-S server. Supports Claude Code, Cline, Codex, Cursor, Windsurf, and many more AI coding agents.
+
+## Usage
+
+```bash
+npx @mcp-s/skills --org <org> [options]
+# or
+npx @mcp-s/skills --base-url <url> [options]
+```
+
+### Options
+
+- `-o, --org <org>` - Organization name (builds URL as `https://<org>.mcp-s.com/skills`)
+- `-b, --base-url <url>` - Full base URL of the MCP-S skills server
+- `-g, --global` - Install skill globally (user-level) instead of project-level
+- `-a, --agent <agents...>` - Specify agents to install to (claude-code, cline, codex, cursor, etc.)
+- `-s, --skill <skills...>` - Specify skill slugs to install (skip selection prompt)
+- `-l, --list` - List available skills without installing
+- `-y, --yes` - Skip confirmation prompts
+- `--all` - Install all skills to all agents without any prompts (implies -y -g)
+
+## Authentication
+
+The CLI automatically handles authentication. On first run, it will:
+1. Generate authentication credentials
+2. Open your browser to complete authentication
+3. Save the credentials for future use
+
+Credentials are stored in `~/.mcp-s/skills-config.json`.
+
+## Examples
+
+### List available skills
+
+```bash
+npx @mcp-s/skills --org mycompany --list
+```
+
+### Install specific skills
+
+```bash
+npx @mcp-s/skills --org mycompany -s skill-1 skill-2
+```
+
+### Install to specific agents
+
+```bash
+npx @mcp-s/skills --org mycompany -a cursor claude-code
+```
+
+### Install all skills globally without prompts
+
+```bash
+npx @mcp-s/skills --org mycompany --all
+```
+
+### Using a custom base URL
+
+```bash
+npx @mcp-s/skills --base-url https://custom.example.com/skills --list
+```
+
+## Supported Agents
+
+- Amp
+- Antigravity
+- Claude Code
+- Clawdbot
+- Cline
+- Codex
+- Command Code
+- Cursor
+- Droid
+- Gemini CLI
+- GitHub Copilot
+- Goose
+- Kilo Code
+- Kiro CLI
+- MCPJam
+- Neovate
+- OpenCode
+- OpenHands
+- Pi
+- Qoder
+- Qwen Code
+- Roo Code
+- Trae
+- Windsurf
+- Zencoder
+
+## Server API
+
+The skills library expects the server to implement the following endpoints:
+
+### POST /generate-auth-url
+
+Generates an authentication URL for the user.
+
+**Headers:**
+- `Authorization: <userAccessKey>:<userOTT>`
+
+**Response:**
+```json
+{
+  "data": {
+    "url": "https://..."
+  }
+}
+```
+
+### GET /skills
+
+Returns a list of available skills.
+
+**Headers:**
+- `Authorization: <userAccessKey>:<userOTT>`
+
+**Response:**
+```json
+{
+  "data": [
+    {
+      "name": "Skill Name",
+      "slug": "skill-slug",
+      "description": "Skill description",
+      "content": "# SKILL.md content...",
+      "category": "optional-category"
+    }
+  ]
+}
+```
+
+## License
+
+ISC

package/dist/agents.js

@@ -0,0 +1,246 @@
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync } from "fs";
+const home = homedir();
+export const agents = {
+    amp: {
+        name: "amp",
+        displayName: "Amp",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: join(home, ".config/agents/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".config/amp"));
+        },
+    },
+    antigravity: {
+        name: "antigravity",
+        displayName: "Antigravity",
+        skillsDir: ".agent/skills",
+        globalSkillsDir: join(home, ".gemini/antigravity/skills"),
+        detectInstalled: async () => {
+            return (existsSync(join(process.cwd(), ".agent")) ||
+                existsSync(join(home, ".gemini/antigravity")));
+        },
+    },
+    "claude-code": {
+        name: "claude-code",
+        displayName: "Claude Code",
+        skillsDir: ".claude/skills",
+        globalSkillsDir: join(home, ".claude/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".claude"));
+        },
+    },
+    clawdbot: {
+        name: "clawdbot",
+        displayName: "Clawdbot",
+        skillsDir: "skills",
+        globalSkillsDir: join(home, ".clawdbot/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".clawdbot"));
+        },
+    },
+    cline: {
+        name: "cline",
+        displayName: "Cline",
+        skillsDir: ".cline/skills",
+        globalSkillsDir: join(home, ".cline/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".cline"));
+        },
+    },
+    codex: {
+        name: "codex",
+        displayName: "Codex",
+        skillsDir: ".codex/skills",
+        globalSkillsDir: join(home, ".codex/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".codex"));
+        },
+    },
+    "command-code": {
+        name: "command-code",
+        displayName: "Command Code",
+        skillsDir: ".commandcode/skills",
+        globalSkillsDir: join(home, ".commandcode/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".commandcode"));
+        },
+    },
+    cursor: {
+        name: "cursor",
+        displayName: "Cursor",
+        skillsDir: ".cursor/skills",
+        globalSkillsDir: join(home, ".cursor/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".cursor"));
+        },
+    },
+    droid: {
+        name: "droid",
+        displayName: "Droid",
+        skillsDir: ".factory/skills",
+        globalSkillsDir: join(home, ".factory/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".factory/skills"));
+        },
+    },
+    "gemini-cli": {
+        name: "gemini-cli",
+        displayName: "Gemini CLI",
+        skillsDir: ".gemini/skills",
+        globalSkillsDir: join(home, ".gemini/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".gemini"));
+        },
+    },
+    "github-copilot": {
+        name: "github-copilot",
+        displayName: "GitHub Copilot",
+        skillsDir: ".github/skills",
+        globalSkillsDir: join(home, ".copilot/skills"),
+        detectInstalled: async () => {
+            return (existsSync(join(process.cwd(), ".github")) ||
+                existsSync(join(home, ".copilot")));
+        },
+    },
+    goose: {
+        name: "goose",
+        displayName: "Goose",
+        skillsDir: ".goose/skills",
+        globalSkillsDir: join(home, ".config/goose/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".config/goose"));
+        },
+    },
+    kilo: {
+        name: "kilo",
+        displayName: "Kilo Code",
+        skillsDir: ".kilocode/skills",
+        globalSkillsDir: join(home, ".kilocode/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".kilocode"));
+        },
+    },
+    "kiro-cli": {
+        name: "kiro-cli",
+        displayName: "Kiro CLI",
+        skillsDir: ".kiro/skills",
+        globalSkillsDir: join(home, ".kiro/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".kiro"));
+        },
+    },
+    mcpjam: {
+        name: "mcpjam",
+        displayName: "MCPJam",
+        skillsDir: ".mcpjam/skills",
+        globalSkillsDir: join(home, ".mcpjam/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".mcpjam"));
+        },
+    },
+    opencode: {
+        name: "opencode",
+        displayName: "OpenCode",
+        skillsDir: ".opencode/skills",
+        globalSkillsDir: join(home, ".config/opencode/skills"),
+        detectInstalled: async () => {
+            return (existsSync(join(home, ".config/opencode")) ||
+                existsSync(join(home, ".claude/skills")));
+        },
+    },
+    openhands: {
+        name: "openhands",
+        displayName: "OpenHands",
+        skillsDir: ".openhands/skills",
+        globalSkillsDir: join(home, ".openhands/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".openhands"));
+        },
+    },
+    pi: {
+        name: "pi",
+        displayName: "Pi",
+        skillsDir: ".pi/skills",
+        globalSkillsDir: join(home, ".pi/agent/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".pi/agent"));
+        },
+    },
+    qoder: {
+        name: "qoder",
+        displayName: "Qoder",
+        skillsDir: ".qoder/skills",
+        globalSkillsDir: join(home, ".qoder/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".qoder"));
+        },
+    },
+    "qwen-code": {
+        name: "qwen-code",
+        displayName: "Qwen Code",
+        skillsDir: ".qwen/skills",
+        globalSkillsDir: join(home, ".qwen/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".qwen"));
+        },
+    },
+    roo: {
+        name: "roo",
+        displayName: "Roo Code",
+        skillsDir: ".roo/skills",
+        globalSkillsDir: join(home, ".roo/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".roo"));
+        },
+    },
+    trae: {
+        name: "trae",
+        displayName: "Trae",
+        skillsDir: ".trae/skills",
+        globalSkillsDir: join(home, ".trae/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".trae"));
+        },
+    },
+    windsurf: {
+        name: "windsurf",
+        displayName: "Windsurf",
+        skillsDir: ".windsurf/skills",
+        globalSkillsDir: join(home, ".codeium/windsurf/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".codeium/windsurf"));
+        },
+    },
+    zencoder: {
+        name: "zencoder",
+        displayName: "Zencoder",
+        skillsDir: ".zencoder/skills",
+        globalSkillsDir: join(home, ".zencoder/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".zencoder"));
+        },
+    },
+    neovate: {
+        name: "neovate",
+        displayName: "Neovate",
+        skillsDir: ".neovate/skills",
+        globalSkillsDir: join(home, ".neovate/skills"),
+        detectInstalled: async () => {
+            return existsSync(join(home, ".neovate"));
+        },
+    },
+};
+export async function detectInstalledAgents() {
+    const installed = [];
+    for (const [type, config] of Object.entries(agents)) {
+        if (await config.detectInstalled()) {
+            installed.push(type);
+        }
+    }
+    return installed;
+}
+export function getAgentConfig(type) {
+    return agents[type];
+}

package/dist/api.js

@@ -0,0 +1,45 @@
+export async function fetchSkills(baseUrl, auth) {
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (auth) {
+        headers["Authorization"] = `${auth.userAccessKey}:${auth.userOTT}`;
+    }
+    const response = await fetch(`${baseUrl}/skills`, {
+        headers,
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        // Check for authentication error
+        if (response.status === 401) {
+            const error = new Error("Unauthorized");
+            error.status = 401;
+            throw error;
+        }
+        throw new Error(`Failed to fetch skills: ${response.status} ${response.statusText}\n${errorText}`);
+    }
+    const data = await response.json();
+    return data.data;
+}
+export async function fetchSkillContent(baseUrl, skillSlug, auth) {
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (auth) {
+        headers["Authorization"] = `${auth.userAccessKey}:${auth.userOTT}`;
+    }
+    const response = await fetch(`${baseUrl}/skills/${skillSlug}/content`, {
+        headers,
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        if (response.status === 401) {
+            const error = new Error("Unauthorized");
+            error.status = 401;
+            throw error;
+        }
+        throw new Error(`Failed to fetch skill content: ${response.status} ${response.statusText}\n${errorText}`);
+    }
+    const data = await response.json();
+    return data.content;
+}

package/dist/auth.js

@@ -0,0 +1,98 @@
+import { homedir } from "os";
+import { join } from "path";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import crypto from "crypto";
+import open from "open";
+const CONFIG_DIR = join(homedir(), ".mcp-s");
+const CONFIG_FILE = join(CONFIG_DIR, "skills-config.json");
+export const generateToken = () => crypto.randomBytes(32).toString("hex");
+export async function loadAuthConfig() {
+    try {
+        if (!existsSync(CONFIG_FILE)) {
+            return null;
+        }
+        const content = await readFile(CONFIG_FILE, "utf-8");
+        return JSON.parse(content);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+export async function saveAuthConfig(config) {
+    if (!existsSync(CONFIG_DIR)) {
+        await mkdir(CONFIG_DIR, { recursive: true });
+    }
+    await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+export async function generateAuthUrl({ baseUrl, userAccessKey, userOTT, }) {
+    const response = await fetch(`${baseUrl}/generate-auth-url`, {
+        method: "POST",
+        headers: {
+            Authorization: `${userAccessKey}:${userOTT}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to generate auth URL: ${response.status}`);
+    }
+    const { data: { url }, } = await response.json();
+    return url;
+}
+export async function authenticate({ baseUrl, userAccessKey, userOTT, openBrowser = true, }) {
+    const url = await generateAuthUrl({ baseUrl, userAccessKey, userOTT });
+    let opened = false;
+    if (openBrowser) {
+        try {
+            await open(url);
+            opened = true;
+        }
+        catch (_a) {
+            // Browser opening failed, user will need to use the URL manually
+        }
+    }
+    return { url, opened };
+}
+export async function getOrCreateAuth(org) {
+    const existing = await loadAuthConfig();
+    if (existing && existing.userAccessKey && existing.userOTT) {
+        // If org changed, generate new OTT
+        if (org && existing.org !== org) {
+            const newOTT = generateToken();
+            await saveAuthConfig(Object.assign(Object.assign({}, existing), { userOTT: newOTT, org }));
+            return {
+                userAccessKey: existing.userAccessKey,
+                userOTT: newOTT,
+                isNew: true,
+            };
+        }
+        return {
+            userAccessKey: existing.userAccessKey,
+            userOTT: existing.userOTT,
+            isNew: false,
+        };
+    }
+    // Create new auth
+    const userAccessKey = generateToken();
+    const userOTT = generateToken();
+    await saveAuthConfig({
+        userAccessKey,
+        userOTT,
+        org,
+    });
+    return {
+        userAccessKey,
+        userOTT,
+        isNew: true,
+    };
+}
+export async function refreshToken(org) {
+    const existing = await loadAuthConfig();
+    const userAccessKey = (existing === null || existing === void 0 ? void 0 : existing.userAccessKey) || generateToken();
+    const userOTT = generateToken();
+    await saveAuthConfig({
+        userAccessKey,
+        userOTT,
+        org,
+    });
+    return { userAccessKey, userOTT };
+}

package/dist/index.js

@@ -0,0 +1,482 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { homedir } from "os";
+import { fetchSkills } from "./api.js";
+import { detectInstalledAgents, agents } from "./agents.js";
+import { installSkillForAgent, isSkillInstalled, getCanonicalPath, } from "./installer.js";
+import { getOrCreateAuth, refreshToken, authenticate, saveAuthConfig, } from "./auth.js";
+function shortenPath(fullPath, cwd) {
+    const home = homedir();
+    if (fullPath.startsWith(home)) {
+        return fullPath.replace(home, "~");
+    }
+    if (fullPath.startsWith(cwd)) {
+        return "." + fullPath.slice(cwd.length);
+    }
+    return fullPath;
+}
+function formatList(items, maxShow = 5) {
+    if (items.length <= maxShow) {
+        return items.join(", ");
+    }
+    const shown = items.slice(0, maxShow);
+    const remaining = items.length - maxShow;
+    return `${shown.join(", ")} +${remaining} more`;
+}
+function buildBaseUrl(org, baseUrl) {
+    if (baseUrl) {
+        return baseUrl;
+    }
+    if (org) {
+        return `https://${org}.mcp-s.com/skills`;
+    }
+    throw new Error("Either --org or --base-url must be provided");
+}
+program
+    .name("skills")
+    .description("Install skills onto coding agents from MCP-S server (Claude Code, Cline, Codex, Cursor, and more)")
+    .version("1.0.0")
+    .option("-o, --org <org>", "Organization name (builds URL as https://<org>.mcp-s.com/skills)")
+    .option("-b, --base-url <url>", "Full base URL of the MCP-S skills server")
+    .option("-g, --global", "Install skill globally (user-level) instead of project-level")
+    .option("-a, --agent <agents...>", "Specify agents to install to (claude-code, cline, codex, cursor, and more)")
+    .option("-s, --skill <skills...>", "Specify skill slugs to install (skip selection prompt)")
+    .option("-l, --list", "List available skills without installing")
+    .option("-y, --yes", "Skip confirmation prompts")
+    .option("--all", "Install all skills to all agents without any prompts (implies -y -g)")
+    .configureOutput({
+    outputError: (str, write) => {
+        if (str.includes("error: required option")) {
+            console.log();
+            console.log(chalk.bgRed.white.bold(" ERROR ") +
+                " " +
+                chalk.red("Missing required option: --org or --base-url"));
+            console.log();
+            console.log(chalk.dim(" Usage:"));
+            console.log(`   ${chalk.cyan("npx @mcp-s/skills")} ${chalk.yellow("--org <org>")} ${chalk.dim("[options]")}`);
+            console.log(`   ${chalk.cyan("npx @mcp-s/skills")} ${chalk.yellow("--base-url <url>")} ${chalk.dim("[options]")}`);
+            console.log();
+            console.log(chalk.dim(" Examples:"));
+            console.log(`   ${chalk.cyan("npx @mcp-s/skills")} ${chalk.yellow("--org mycompany")}`);
+            console.log(`   ${chalk.cyan("npx @mcp-s/skills")} ${chalk.yellow("--base-url https://custom.example.com/skills")}`);
+            console.log();
+            console.log(chalk.dim(" Run") +
+                ` ${chalk.cyan("npx @mcp-s/skills --help")}` +
+                chalk.dim(" for more information."));
+            console.log();
+        }
+        else {
+            write(str);
+        }
+    },
+})
+    .action(async (options) => {
+    await main(options);
+});
+program.parse();
+async function main(options) {
+    var _a;
+    // Validate that either org or baseUrl is provided
+    if (!options.org && !options.baseUrl) {
+        console.log();
+        console.log(chalk.bgRed.white.bold(" ERROR ") +
+            " " +
+            chalk.red("Missing required option: --org or --base-url"));
+        console.log();
+        console.log(chalk.dim(" Usage:"));
+        console.log(`   ${chalk.cyan("npx @mcp-s/skills")} ${chalk.yellow("--org <org>")} ${chalk.dim("[options]")}`);
+        console.log(`   ${chalk.cyan("npx @mcp-s/skills")} ${chalk.yellow("--base-url <url>")} ${chalk.dim("[options]")}`);
+        console.log();
+        process.exit(1);
+    }
+    if (options.all) {
+        options.yes = true;
+        options.global = true;
+    }
+    console.log();
+    p.intro(chalk.bgCyan.black(" MCP-S Skills "));
+    const spinner = p.spinner();
+    const baseUrl = buildBaseUrl(options.org, options.baseUrl);
+    try {
+        // Get or create authentication
+        spinner.start("Checking authentication...");
+        let auth = await getOrCreateAuth(options.org);
+        spinner.stop(auth.isNew
+            ? "New authentication created"
+            : "Using existing authentication");
+        // Try to fetch skills
+        spinner.start("Fetching skills from server...");
+        let skills;
+        let needsAuth = false;
+        try {
+            skills = await fetchSkills(baseUrl, auth);
+        }
+        catch (error) {
+            if (error &&
+                typeof error === "object" &&
+                "status" in error &&
+                error.status === 401) {
+                needsAuth = true;
+                skills = [];
+            }
+            else {
+                throw error;
+            }
+        }
+        // Handle authentication if needed
+        if (needsAuth || auth.isNew) {
+            spinner.stop("Authentication required");
+            p.log.info("You need to authenticate to access skills.");
+            // Generate new token and authenticate
+            const newAuth = await refreshToken(options.org);
+            auth = Object.assign(Object.assign({}, newAuth), { isNew: true });
+            const { url, opened } = await authenticate({
+                baseUrl,
+                userAccessKey: auth.userAccessKey,
+                userOTT: auth.userOTT,
+                openBrowser: true,
+            });
+            if (opened) {
+                p.log.info("Opening authentication page in your browser...");
+            }
+            else {
+                p.log.info("Please open this URL in your browser to authenticate:");
+                p.log.message(chalk.cyan(url));
+            }
+            // Wait for user confirmation
+            const confirmed = await p.confirm({
+                message: "Have you completed authentication in the browser?",
+            });
+            if (p.isCancel(confirmed) || !confirmed) {
+                p.cancel("Authentication cancelled");
+                process.exit(0);
+            }
+            // Save the auth config
+            await saveAuthConfig({
+                userAccessKey: auth.userAccessKey,
+                userOTT: auth.userOTT,
+                org: options.org,
+            });
+            // Retry fetching skills
+            spinner.start("Fetching skills from server...");
+            try {
+                skills = await fetchSkills(baseUrl, auth);
+            }
+            catch (error) {
+                if (error &&
+                    typeof error === "object" &&
+                    "status" in error &&
+                    error.status === 401) {
+                    spinner.stop(chalk.red("Authentication failed"));
+                    p.log.error("Authentication failed. Please try again or check your credentials.");
+                    process.exit(1);
+                }
+                throw error;
+            }
+        }
+        spinner.stop(`Found ${skills.length} skill${skills.length !== 1 ? "s" : ""}`);
+        if (skills.length === 0) {
+            p.log.warn("No skills available on this server.");
+            p.outro(chalk.yellow("Nothing to install."));
+            process.exit(0);
+        }
+        // List mode
+        if (options.list) {
+            console.log();
+            p.log.step(chalk.bold("Available Skills"));
+            for (const skill of skills) {
+                p.log.message(`  ${chalk.cyan(skill.slug || skill.name)} - ${chalk.dim(skill.description)}`);
+            }
+            console.log();
+            p.outro("Run without --list to install");
+            process.exit(0);
+        }
+        // Select skills
+        let selectedSkills;
+        if (options.skill && options.skill.length > 0) {
+            // Filter by specified skill slugs
+            selectedSkills = skills.filter((s) => options.skill.includes(s.slug) || options.skill.includes(s.name));
+            if (selectedSkills.length === 0) {
+                p.log.error(`No matching skills found for: ${options.skill.join(", ")}`);
+                p.log.info(`Available skills: ${skills.map((s) => s.slug || s.name).join(", ")}`);
+                process.exit(1);
+            }
+        }
+        else if (options.all) {
+            selectedSkills = skills;
+        }
+        else {
+            // Interactive selection
+            const skillChoices = skills.map((s) => ({
+                value: s,
+                label: s.name,
+                hint: s.description,
+            }));
+            const selected = await p.multiselect({
+                message: "Select skills to install",
+                options: skillChoices,
+                required: true,
+            });
+            if (p.isCancel(selected)) {
+                p.cancel("Installation cancelled");
+                process.exit(0);
+            }
+            selectedSkills = selected;
+        }
+        p.log.info(`Selected ${selectedSkills.length} skill${selectedSkills.length !== 1 ? "s" : ""}: ${chalk.cyan(selectedSkills.map((s) => s.slug || s.name).join(", "))}`);
+        // Select agents
+        let targetAgents;
+        const validAgents = Object.keys(agents);
+        if (options.agent && options.agent.length > 0) {
+            const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+            if (invalidAgents.length > 0) {
+                p.log.error(`Invalid agents: ${invalidAgents.join(", ")}`);
+                p.log.info(`Valid agents: ${validAgents.join(", ")}`);
+                process.exit(1);
+            }
+            targetAgents = options.agent;
+        }
+        else {
+            spinner.start("Detecting installed agents...");
+            const installedAgents = await detectInstalledAgents();
+            spinner.stop(`Detected ${installedAgents.length} agent${installedAgents.length !== 1 ? "s" : ""}`);
+            if (installedAgents.length === 0) {
+                if (options.yes) {
+                    targetAgents = validAgents;
+                    p.log.info("Installing to all agents (none detected)");
+                }
+                else {
+                    p.log.warn("No coding agents detected. You can still install skills.");
+                    const allAgentChoices = Object.entries(agents).map(([key, config]) => ({
+                        value: key,
+                        label: config.displayName,
+                    }));
+                    const selected = await p.multiselect({
+                        message: "Select agents to install skills to",
+                        options: allAgentChoices,
+                        required: true,
+                        initialValues: Object.keys(agents),
+                    });
+                    if (p.isCancel(selected)) {
+                        p.cancel("Installation cancelled");
+                        process.exit(0);
+                    }
+                    targetAgents = selected;
+                }
+            }
+            else if (installedAgents.length === 1 || options.yes) {
+                targetAgents = installedAgents;
+                if (installedAgents.length === 1) {
+                    const firstAgent = installedAgents[0];
+                    p.log.info(`Installing to: ${chalk.cyan(agents[firstAgent].displayName)}`);
+                }
+                else {
+                    p.log.info(`Installing to: ${installedAgents.map((a) => chalk.cyan(agents[a].displayName)).join(", ")}`);
+                }
+            }
+            else {
+                const agentChoices = installedAgents.map((a) => ({
+                    value: a,
+                    label: agents[a].displayName,
+                    hint: `${options.global ? agents[a].globalSkillsDir : agents[a].skillsDir}`,
+                }));
+                const selected = await p.multiselect({
+                    message: "Select agents to install skills to",
+                    options: agentChoices,
+                    required: true,
+                    initialValues: installedAgents,
+                });
+                if (p.isCancel(selected)) {
+                    p.cancel("Installation cancelled");
+                    process.exit(0);
+                }
+                targetAgents = selected;
+            }
+        }
+        // Installation scope
+        let installGlobally = (_a = options.global) !== null && _a !== void 0 ? _a : false;
+        if (options.global === undefined && !options.yes) {
+            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)) {
+                p.cancel("Installation cancelled");
+                process.exit(0);
+            }
+            installGlobally = scope;
+        }
+        // Installation method
+        let installMode = "symlink";
+        if (!options.yes) {
+            const modeChoice = await p.select({
+                message: "Installation method",
+                options: [
+                    {
+                        value: "symlink",
+                        label: "Symlink (Recommended)",
+                        hint: "Single source of truth, easy updates",
+                    },
+                    {
+                        value: "copy",
+                        label: "Copy to all agents",
+                        hint: "Independent copies for each agent",
+                    },
+                ],
+            });
+            if (p.isCancel(modeChoice)) {
+                p.cancel("Installation cancelled");
+                process.exit(0);
+            }
+            installMode = modeChoice;
+        }
+        // Check for existing installations
+        const cwd = process.cwd();
+        const overwriteStatus = new Map();
+        for (const skill of selectedSkills) {
+            const skillStatus = new Map();
+            for (const agent of targetAgents) {
+                skillStatus.set(agent, await isSkillInstalled(skill.slug || skill.name, agent, {
+                    global: installGlobally,
+                }));
+            }
+            overwriteStatus.set(skill.slug || skill.name, skillStatus);
+        }
+        // Show summary
+        const summaryLines = [];
+        const agentNames = targetAgents.map((a) => agents[a].displayName);
+        for (const skill of selectedSkills) {
+            const skillName = skill.slug || skill.name;
+            if (installMode === "symlink") {
+                const canonicalPath = getCanonicalPath(skillName, {
+                    global: installGlobally,
+                });
+                const shortCanonical = shortenPath(canonicalPath, cwd);
+                summaryLines.push(`${chalk.cyan(skillName)}`);
+                summaryLines.push(`  ${chalk.dim(shortCanonical)}`);
+                summaryLines.push(`  ${chalk.dim("symlink →")} ${formatList(agentNames)}`);
+            }
+            else {
+                summaryLines.push(`${chalk.cyan(skillName)}`);
+                summaryLines.push(`  ${chalk.dim("copy →")} ${formatList(agentNames)}`);
+            }
+            const skillOverwrites = overwriteStatus.get(skillName);
+            const overwriteAgents = targetAgents
+                .filter((a) => skillOverwrites === null || skillOverwrites === void 0 ? void 0 : skillOverwrites.get(a))
+                .map((a) => agents[a].displayName);
+            if (overwriteAgents.length > 0) {
+                summaryLines.push(`  ${chalk.yellow("overwrites:")} ${formatList(overwriteAgents)}`);
+            }
+        }
+        console.log();
+        p.note(summaryLines.join("\n"), "Installation Summary");
+        // Confirm
+        if (!options.yes) {
+            const confirmed = await p.confirm({
+                message: "Proceed with installation?",
+            });
+            if (p.isCancel(confirmed) || !confirmed) {
+                p.cancel("Installation cancelled");
+                process.exit(0);
+            }
+        }
+        // Install
+        spinner.start("Installing skills...");
+        const results = [];
+        for (const skill of selectedSkills) {
+            for (const agent of targetAgents) {
+                const result = await installSkillForAgent(skill, agent, {
+                    global: installGlobally,
+                    mode: installMode,
+                });
+                results.push(Object.assign({ skill: skill.slug || skill.name, agent: agents[agent].displayName }, result));
+            }
+        }
+        spinner.stop("Installation complete");
+        console.log();
+        const successful = results.filter((r) => r.success);
+        const failed = results.filter((r) => !r.success);
+        if (successful.length > 0) {
+            const resultLines = [];
+            // Group by skill
+            const skillGroups = new Map();
+            for (const r of successful) {
+                if (!skillGroups.has(r.skill)) {
+                    skillGroups.set(r.skill, []);
+                }
+                skillGroups.get(r.skill).push(r);
+            }
+            for (const [skillName, skillResults] of skillGroups) {
+                const firstResult = skillResults[0];
+                if (firstResult.mode === "copy") {
+                    resultLines.push(`${chalk.green("✓")} ${skillName} ${chalk.dim("(copied)")}`);
+                    for (const r of skillResults) {
+                        const shortPath = shortenPath(r.path, cwd);
+                        resultLines.push(`  ${chalk.dim("→")} ${r.agent}: ${shortPath}`);
+                    }
+                }
+                else {
+                    if (firstResult.canonicalPath) {
+                        const shortPath = shortenPath(firstResult.canonicalPath, cwd);
+                        resultLines.push(`${chalk.green("✓")} ${skillName}`);
+                        resultLines.push(`  ${chalk.dim(shortPath)}`);
+                    }
+                    else {
+                        resultLines.push(`${chalk.green("✓")} ${skillName}`);
+                    }
+                    const symlinked = skillResults
+                        .filter((r) => !r.symlinkFailed)
+                        .map((r) => r.agent);
+                    const copied = skillResults
+                        .filter((r) => r.symlinkFailed)
+                        .map((r) => r.agent);
+                    if (symlinked.length > 0) {
+                        resultLines.push(`  ${chalk.dim("symlink →")} ${formatList(symlinked)}`);
+                    }
+                    if (copied.length > 0) {
+                        resultLines.push(`  ${chalk.yellow("copied →")} ${formatList(copied)}`);
+                    }
+                }
+            }
+            const skillCount = skillGroups.size;
+            const agentCount = new Set(successful.map((r) => r.agent)).size;
+            const title = chalk.green(`Installed ${skillCount} skill${skillCount !== 1 ? "s" : ""} to ${agentCount} agent${agentCount !== 1 ? "s" : ""}`);
+            p.note(resultLines.join("\n"), title);
+            const symlinkFailures = successful.filter((r) => r.mode === "symlink" && r.symlinkFailed);
+            if (symlinkFailures.length > 0) {
+                const copiedAgentNames = [
+                    ...new Set(symlinkFailures.map((r) => r.agent)),
+                ];
+                p.log.warn(chalk.yellow(`Symlinks failed for: ${formatList(copiedAgentNames)}`));
+                p.log.message(chalk.dim("  Files were copied instead. On Windows, enable Developer Mode for symlink support."));
+            }
+        }
+        if (failed.length > 0) {
+            console.log();
+            p.log.error(chalk.red(`Failed to install ${failed.length}`));
+            for (const r of failed) {
+                p.log.message(`  ${chalk.red("✗")} ${r.skill} → ${r.agent}: ${chalk.dim(r.error)}`);
+            }
+        }
+        console.log();
+        p.outro(chalk.green("Done!"));
+    }
+    catch (error) {
+        spinner.stop(chalk.red("Error"));
+        p.log.error(chalk.red(error instanceof Error ? error.message : "Unknown error"));
+        process.exit(1);
+    }
+}

package/dist/installer.js

@@ -0,0 +1,188 @@
+import { mkdir, access, symlink, lstat, rm, readlink, writeFile, } from "fs/promises";
+import { join, normalize, resolve, sep, relative } from "path";
+import { homedir, platform } from "os";
+import { agents } from "./agents.js";
+const AGENTS_DIR = ".agents";
+const SKILLS_SUBDIR = "skills";
+function sanitizeName(name) {
+    let sanitized = name.replace(/[\/\\:\0]/g, "");
+    sanitized = sanitized.replace(/^[.\s]+|[.\s]+$/g, "");
+    sanitized = sanitized.replace(/^\.+/, "");
+    if (!sanitized || sanitized.length === 0) {
+        sanitized = "unnamed-skill";
+    }
+    if (sanitized.length > 255) {
+        sanitized = sanitized.substring(0, 255);
+    }
+    return sanitized;
+}
+function isPathSafe(basePath, targetPath) {
+    const normalizedBase = normalize(resolve(basePath));
+    const normalizedTarget = normalize(resolve(targetPath));
+    return (normalizedTarget.startsWith(normalizedBase + sep) ||
+        normalizedTarget === normalizedBase);
+}
+function getCanonicalSkillsDir(global, cwd) {
+    const baseDir = global ? homedir() : cwd || process.cwd();
+    return join(baseDir, AGENTS_DIR, SKILLS_SUBDIR);
+}
+async function createSymlink(target, linkPath) {
+    try {
+        try {
+            const stats = await lstat(linkPath);
+            if (stats.isSymbolicLink()) {
+                const existingTarget = await readlink(linkPath);
+                if (resolve(existingTarget) === resolve(target)) {
+                    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 (_a) {
+                    // Ignore cleanup errors
+                }
+            }
+        }
+        const linkDir = join(linkPath, "..");
+        await mkdir(linkDir, { recursive: true });
+        const relativePath = relative(linkDir, target);
+        const symlinkType = platform() === "win32" ? "junction" : undefined;
+        await symlink(relativePath, linkPath, symlinkType);
+        return true;
+    }
+    catch (_b) {
+        return false;
+    }
+}
+export async function installSkillForAgent(skill, agentType, options = {}) {
+    var _a, _b;
+    const agent = agents[agentType];
+    const isGlobal = (_a = options.global) !== null && _a !== void 0 ? _a : false;
+    const cwd = options.cwd || process.cwd();
+    const skillName = sanitizeName(skill.slug || skill.name);
+    const canonicalBase = getCanonicalSkillsDir(isGlobal, cwd);
+    const canonicalDir = join(canonicalBase, skillName);
+    const agentBase = isGlobal
+        ? agent.globalSkillsDir
+        : join(cwd, agent.skillsDir);
+    const agentDir = join(agentBase, skillName);
+    const installMode = (_b = options.mode) !== null && _b !== void 0 ? _b : "symlink";
+    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",
+        };
+    }
+    try {
+        if (installMode === "copy") {
+            await mkdir(agentDir, { recursive: true });
+            const skillMdPath = join(agentDir, "SKILL.md");
+            await writeFile(skillMdPath, skill.content, "utf-8");
+            return {
+                success: true,
+                path: agentDir,
+                mode: "copy",
+            };
+        }
+        // Symlink mode
+        await mkdir(canonicalDir, { recursive: true });
+        const skillMdPath = join(canonicalDir, "SKILL.md");
+        await writeFile(skillMdPath, skill.content, "utf-8");
+        const symlinkCreated = await createSymlink(canonicalDir, agentDir);
+        if (!symlinkCreated) {
+            // Fallback to copy
+            try {
+                await rm(agentDir, { recursive: true, force: true });
+            }
+            catch (_c) {
+                // Ignore
+            }
+            await mkdir(agentDir, { recursive: true });
+            const agentSkillMdPath = join(agentDir, "SKILL.md");
+            await writeFile(agentSkillMdPath, skill.content, "utf-8");
+            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",
+        };
+    }
+}
+export async function isSkillInstalled(skillName, agentType, options = {}) {
+    const agent = agents[agentType];
+    const sanitized = sanitizeName(skillName);
+    const targetBase = options.global
+        ? agent.globalSkillsDir
+        : join(options.cwd || process.cwd(), agent.skillsDir);
+    const skillDir = join(targetBase, sanitized);
+    if (!isPathSafe(targetBase, skillDir)) {
+        return false;
+    }
+    try {
+        await access(skillDir);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+export function getInstallPath(skillName, agentType, options = {}) {
+    const agent = agents[agentType];
+    const cwd = options.cwd || process.cwd();
+    const sanitized = sanitizeName(skillName);
+    const targetBase = options.global
+        ? agent.globalSkillsDir
+        : join(cwd, agent.skillsDir);
+    const installPath = join(targetBase, sanitized);
+    if (!isPathSafe(targetBase, installPath)) {
+        throw new Error("Invalid skill name: potential path traversal detected");
+    }
+    return installPath;
+}
+export function getCanonicalPath(skillName, options = {}) {
+    var _a;
+    const sanitized = sanitizeName(skillName);
+    const canonicalBase = getCanonicalSkillsDir((_a = options.global) !== null && _a !== void 0 ? _a : false, options.cwd);
+    const canonicalPath = join(canonicalBase, sanitized);
+    if (!isPathSafe(canonicalBase, canonicalPath)) {
+        throw new Error("Invalid skill name: potential path traversal detected");
+    }
+    return canonicalPath;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@mcp-s/skills",
+  "version": "1.0.2",
+  "description": "Install skills onto coding agents from MCP-S server",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "bin": {
+    "skills": "dist/index.js"
+  },
+  "scripts": {
+    "start": "node dist/index.js",
+    "build": "tsc && shx chmod +x dist/*.js",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build && npm version patch",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "MCP-S",
+  "license": "ISC",
+  "keywords": [
+    "cli",
+    "agent-skills",
+    "skills",
+    "ai-agents",
+    "mcp-s",
+    "claude-code",
+    "cline",
+    "codex",
+    "cursor",
+    "opencode",
+    "openhands",
+    "windsurf"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "open": "^10.1.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.0",
+    "shx": "^0.4.0",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}