@mcp-s/skills 1.0.5 → 1.3.1

package/dist/installer.js

@@ -1,231 +0,0 @@
-import { mkdir, access, symlink, lstat, rm, readlink, writeFile, } from "fs/promises";
-import { join, normalize, resolve, sep, relative, dirname } 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;
-    }
-}
-/**
- * Write all skill files to a directory
- * Structure:
- * skill-name/
- * ├── SKILL.md          # Required: instructions + metadata
- * ├── scripts/          # Optional: executable code
- * ├── references/       # Optional: documentation
- * └── assets/           # Optional: templates, resources
- */
-async function writeSkillFiles(skill, targetDir) {
-    // Ensure the target directory exists
-    await mkdir(targetDir, { recursive: true });
-    // Write SKILL.md
-    const skillMdPath = join(targetDir, "SKILL.md");
-    await writeFile(skillMdPath, skill.content, "utf-8");
-    // Write scripts if present
-    if (skill.scripts && skill.scripts.length > 0) {
-        for (const script of skill.scripts) {
-            const scriptPath = join(targetDir, script.path);
-            const scriptDir = dirname(scriptPath);
-            await mkdir(scriptDir, { recursive: true });
-            await writeFile(scriptPath, script.content, "utf-8");
-        }
-    }
-    // Write references if present
-    if (skill.references && skill.references.length > 0) {
-        for (const reference of skill.references) {
-            const refPath = join(targetDir, reference.path);
-            const refDir = dirname(refPath);
-            await mkdir(refDir, { recursive: true });
-            await writeFile(refPath, reference.content, "utf-8");
-        }
-    }
-    // Write assets if present
-    if (skill.assets && skill.assets.length > 0) {
-        for (const asset of skill.assets) {
-            const assetPath = join(targetDir, asset.path);
-            const assetDir = dirname(assetPath);
-            await mkdir(assetDir, { recursive: true });
-            // Assets may be base64 encoded for binary files
-            if (asset.mimeType && !asset.mimeType.startsWith("text/")) {
-                await writeFile(assetPath, Buffer.from(asset.content, "base64"));
-            }
-            else {
-                await writeFile(assetPath, asset.content, "utf-8");
-            }
-        }
-    }
-}
-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 writeSkillFiles(skill, agentDir);
-            return {
-                success: true,
-                path: agentDir,
-                mode: "copy",
-            };
-        }
-        // Symlink mode
-        await writeSkillFiles(skill, canonicalDir);
-        const symlinkCreated = await createSymlink(canonicalDir, agentDir);
-        if (!symlinkCreated) {
-            // Fallback to copy
-            try {
-                await rm(agentDir, { recursive: true, force: true });
-            }
-            catch (_c) {
-                // Ignore
-            }
-            await writeSkillFiles(skill, agentDir);
-            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 {};