@mcp-s/skills 1.0.5 → 1.3.1

package/dist/index.js

@@ -1,495 +0,0 @@
-#!/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)")
-    .option("-k, --key <userAccessKey>", "Your MCP-S user access key (found in your MCP-S dashboard)")
-    .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;
-        try {
-            auth = await getOrCreateAuth(options.org, options.key);
-        }
-        catch (error) {
-            spinner.stop(chalk.red("Authentication required"));
-            if (error instanceof Error && error.message.includes("No user access key")) {
-                p.log.error(error.message);
-                p.log.info(`You can find your user access key in your MCP-S dashboard at ${chalk.cyan("https://<org>.mcp-s.com/settings")}`);
-                process.exit(1);
-            }
-            throw error;
-        }
-        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, options.key);
-            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);
-    }
-}