@mcp-s/skills 1.0.2 → 1.3.1

package/dist/index.js

@@ -1,482 +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)")
-    .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

@@ -1,188 +0,0 @@
-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

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