alegra-data-agent 0.1.0

package/dist/installer.js

@@ -0,0 +1,499 @@
+import { createHash } from "node:crypto";
+import { copyFileSync, existsSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { dirname, join, resolve, sep } from "node:path";
+import { fetchManifest, fetchSkillFile } from "./api.js";
+import { dim, gray, green, logError, red, yellow } from "./colors.js";
+import { ensureDir, getLockFilePath, getPackageVersion, readLockFile, sha256File, writeLockFile, } from "./lib.js";
+import { renderMcpForTarget } from "./render.js";
+import { detectInstalledTargets, TARGETS } from "./targets.js";
+const SKILL_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+const MCP_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+function validateSkillName(name) {
+    if (!SKILL_NAME_RE.test(name)) {
+        throw new Error(`Nombre de skill inválido: ${JSON.stringify(name)}`);
+    }
+}
+function validateMcpName(name) {
+    if (!MCP_NAME_RE.test(name)) {
+        throw new Error(`Nombre de MCP inválido: ${JSON.stringify(name)}`);
+    }
+}
+function validateRelPath(rel) {
+    if (!rel || typeof rel !== "string") {
+        throw new Error(`Path inválido: ${JSON.stringify(rel)}`);
+    }
+    if (rel.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(rel) || rel.startsWith("\\")) {
+        throw new Error(`Path absoluto rechazado: ${rel}`);
+    }
+    const segments = rel.split(/[/\\]/);
+    for (const s of segments) {
+        if (s === "" || s === "." || s === ".." || s.startsWith(".")) {
+            throw new Error(`Componente peligroso en path: ${rel}`);
+        }
+    }
+}
+function safeJoinSkillFile(skillRoot, rel) {
+    const candidate = resolve(skillRoot, rel);
+    const root = resolve(skillRoot);
+    if (candidate !== root && !candidate.startsWith(root + sep)) {
+        throw new Error(`Path traversal detectado: ${rel}`);
+    }
+    return candidate;
+}
+export function verifyInstalledFiles(dir, entry) {
+    if (!existsSync(dir))
+        return { ok: false, mismatches: ["carpeta no existe"] };
+    const mismatches = [];
+    for (const rel of entry.files) {
+        const full = join(dir, rel);
+        if (!existsSync(full)) {
+            mismatches.push(`${rel} (faltante)`);
+            continue;
+        }
+        const actual = sha256File(full);
+        const expected = entry.sha256[rel];
+        if (actual !== expected) {
+            mismatches.push(`${rel} (hash distinto)`);
+        }
+    }
+    return { ok: mismatches.length === 0, mismatches };
+}
+function sha256Buffer(buf) {
+    return createHash("sha256").update(buf).digest("hex");
+}
+async function stageSkill(skillName, entry) {
+    validateSkillName(skillName);
+    for (const rel of entry.files)
+        validateRelPath(rel);
+    const staged = [];
+    for (const rel of entry.files) {
+        const data = await fetchSkillFile(skillName, rel);
+        const actualHash = sha256Buffer(data);
+        const expectedHash = entry.sha256[rel];
+        if (actualHash !== expectedHash) {
+            throw new Error(`hash inválido para ${skillName}/${rel}: esperaba ${expectedHash.slice(0, 12)}…, recibido ${actualHash.slice(0, 12)}…`);
+        }
+        staged.push({ rel, data });
+    }
+    return staged;
+}
+function writeSkillToTarget(skillName, staged, spec) {
+    validateSkillName(skillName);
+    if (spec.skillFormat === "folder") {
+        const dst = join(spec.skillsDir, skillName);
+        if (existsSync(dst))
+            rmSync(dst, { recursive: true, force: true });
+        ensureDir(dst);
+        for (const f of staged) {
+            const dstFile = safeJoinSkillFile(dst, f.rel);
+            ensureDir(dirname(dstFile));
+            writeFileSync(dstFile, f.data);
+        }
+        return;
+    }
+    const entry = staged.find((f) => f.rel === "SKILL.md" || f.rel === "README.md");
+    if (!entry) {
+        throw new Error(`Para target ${spec.id} se requiere SKILL.md o README.md en la skill`);
+    }
+    const content = new TextDecoder().decode(entry.data);
+    const rendered = renderSkillForTargetFromContent(content, skillName, spec.skillFormat);
+    ensureDir(spec.skillsDir);
+    const dst = join(spec.skillsDir, rendered.filename);
+    atomicWriteFile(dst, rendered.content);
+}
+function renderSkillForTargetFromContent(content, skillName, format) {
+    if (format === "folder") {
+        throw new Error("renderSkillForTargetFromContent no soporta 'folder'");
+    }
+    const stripped = content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, "").replace(/^\s+/, "");
+    const fm = parseFrontmatterMinimal(content);
+    if (format === "cursor-mdc") {
+        const desc = fm.description ?? `Skill ${skillName}`;
+        const cursorDesc = desc.startsWith("USE WHEN") ? desc : `USE WHEN ${desc}`;
+        const safeDesc = cursorDesc.replace(/\n/g, " ").replace(/"/g, '\\"');
+        return {
+            filename: `${skillName}.mdc`,
+            content: `---\ndescription: "${safeDesc}"\nalwaysApply: false\n---\n\n${stripped}`,
+        };
+    }
+    return { filename: `${skillName}.md`, content: stripped };
+}
+function parseFrontmatterMinimal(content) {
+    const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!m)
+        return {};
+    const out = {};
+    for (const line of m[1].split(/\r?\n/)) {
+        const kv = line.match(/^description:\s*(.+)$/);
+        if (kv) {
+            out.description = kv[1].replace(/^["']|["']$/g, "").trim();
+            return out;
+        }
+    }
+    return out;
+}
+function atomicWriteFile(path, content) {
+    ensureDir(dirname(path));
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, content);
+    renameSync(tmp, path);
+}
+function backupIfExists(path) {
+    if (!existsSync(path))
+        return;
+    const bak = `${path}.bak-${Date.now()}`;
+    copyFileSync(path, bak);
+}
+function readJsonOrEmpty(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        throw new Error(`${path} no es JSON válido. Arréglalo manualmente o muévelo y vuelve a instalar.`);
+    }
+}
+function registerMcpInTarget(mcp, spec) {
+    validateMcpName(mcp.name);
+    const cfg = readJsonOrEmpty(spec.mcpConfigPath);
+    const section = cfg[spec.mcpRootKey] ?? {};
+    section[mcp.name] = renderMcpForTarget(mcp, spec);
+    cfg[spec.mcpRootKey] = section;
+    backupIfExists(spec.mcpConfigPath);
+    atomicWriteFile(spec.mcpConfigPath, JSON.stringify(cfg, null, 2) + "\n");
+}
+function unregisterMcpInTarget(mcpName, spec) {
+    if (!existsSync(spec.mcpConfigPath))
+        return false;
+    const cfg = readJsonOrEmpty(spec.mcpConfigPath);
+    const section = cfg[spec.mcpRootKey];
+    if (!section || !(mcpName in section))
+        return false;
+    delete section[mcpName];
+    cfg[spec.mcpRootKey] = section;
+    backupIfExists(spec.mcpConfigPath);
+    atomicWriteFile(spec.mcpConfigPath, JSON.stringify(cfg, null, 2) + "\n");
+    return true;
+}
+function resolveTargets(opts) {
+    const ids = opts.targets?.length
+        ? opts.targets
+        : detectInstalledTargets();
+    if (ids.length === 0) {
+        ids.push("claude-code");
+    }
+    return ids.map((id) => TARGETS[id]);
+}
+export async function installSkill(name, manifest, opts = {}) {
+    const entry = manifest.skills[name];
+    if (!entry) {
+        return { name, kind: "skill", status: "failed", error: "no está en el manifest" };
+    }
+    const lock = readLockFile();
+    const prev = lock.skills[name];
+    const targets = resolveTargets(opts);
+    const targetIds = targets.map((t) => t.id);
+    const targetsMatch = prev?.targets &&
+        prev.targets.length === targetIds.length &&
+        prev.targets.every((t) => targetIds.includes(t));
+    if (prev && prev.bundleHash === entry.bundleHash && targetsMatch && !opts.force) {
+        const folderTarget = targets.find((t) => t.skillFormat === "folder");
+        if (folderTarget) {
+            const dst = join(folderTarget.skillsDir, name);
+            const drift = verifyInstalledFiles(dst, entry);
+            if (drift.ok)
+                return { name, kind: "skill", status: "unchanged", targets: targetIds };
+        }
+        else {
+            return { name, kind: "skill", status: "unchanged", targets: targetIds };
+        }
+    }
+    if (opts.dryRun) {
+        return {
+            name,
+            kind: "skill",
+            status: prev ? "updated" : "installed",
+            targets: targetIds,
+        };
+    }
+    try {
+        const staged = await stageSkill(name, entry);
+        for (const t of targets) {
+            writeSkillToTarget(name, staged, t);
+        }
+        lock.skills[name] = {
+            name,
+            installedFrom: getPackageVersion(),
+            installedAt: new Date().toISOString(),
+            bundleHash: entry.bundleHash,
+            targets: targetIds,
+        };
+        writeLockFile(lock);
+        return {
+            name,
+            kind: "skill",
+            status: prev ? "updated" : "installed",
+            targets: targetIds,
+        };
+    }
+    catch (err) {
+        return {
+            name,
+            kind: "skill",
+            status: "failed",
+            targets: targetIds,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export function installMcp(mcp, opts = {}) {
+    try {
+        validateMcpName(mcp.name);
+    }
+    catch (err) {
+        return {
+            name: mcp.name,
+            kind: "mcp",
+            status: "failed",
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+    const lock = readLockFile();
+    if (!lock.mcps)
+        lock.mcps = {};
+    const wantedTargets = resolveTargets(opts).filter((t) => !mcp.targets || mcp.targets.includes(t.id));
+    const targetIds = wantedTargets.map((t) => t.id);
+    if (targetIds.length === 0) {
+        return {
+            name: mcp.name,
+            kind: "mcp",
+            status: "skipped",
+            error: "ningún target soportado disponible",
+        };
+    }
+    const prev = lock.mcps[mcp.name];
+    const targetsMatch = prev?.targets &&
+        prev.targets.length === targetIds.length &&
+        prev.targets.every((t) => targetIds.includes(t));
+    if (prev && targetsMatch && !opts.force) {
+        return { name: mcp.name, kind: "mcp", status: "unchanged", targets: targetIds };
+    }
+    if (opts.dryRun) {
+        return {
+            name: mcp.name,
+            kind: "mcp",
+            status: prev ? "updated" : "installed",
+            targets: targetIds,
+        };
+    }
+    try {
+        for (const t of wantedTargets) {
+            registerMcpInTarget(mcp, t);
+        }
+        lock.mcps[mcp.name] = {
+            name: mcp.name,
+            installedFrom: getPackageVersion(),
+            installedAt: new Date().toISOString(),
+            targets: targetIds,
+        };
+        writeLockFile(lock);
+        return {
+            name: mcp.name,
+            kind: "mcp",
+            status: prev ? "updated" : "installed",
+            targets: targetIds,
+        };
+    }
+    catch (err) {
+        return {
+            name: mcp.name,
+            kind: "mcp",
+            status: "failed",
+            targets: targetIds,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export async function installAll(opts = {}) {
+    let manifest;
+    try {
+        manifest = await fetchManifest();
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+    if (!manifest)
+        return { error: "No se pudo cargar el manifest del gateway." };
+    const targets = resolveTargets(opts).map((t) => t.id);
+    const skillNames = opts.only && opts.only.length > 0
+        ? opts.only.filter((s) => manifest.skills[s])
+        : Object.keys(manifest.skills);
+    const mcpNames = opts.only && opts.only.length > 0
+        ? opts.only.filter((s) => manifest.mcps && manifest.mcps[s])
+        : Object.keys(manifest.mcps ?? {});
+    const results = [];
+    for (const name of skillNames) {
+        results.push(await installSkill(name, manifest, { ...opts, targets }));
+    }
+    for (const name of mcpNames) {
+        const mcp = manifest.mcps?.[name];
+        if (!mcp)
+            continue;
+        results.push(installMcp(mcp, { ...opts, targets }));
+    }
+    return { manifest, results, targets };
+}
+export function uninstallSkill(name, opts = {}) {
+    try {
+        validateSkillName(name);
+    }
+    catch (err) {
+        return {
+            name,
+            kind: "skill",
+            status: "failed",
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+    const lock = readLockFile();
+    const prev = lock.skills[name];
+    if (!prev) {
+        return { name, kind: "skill", status: "skipped", error: "no estaba instalada" };
+    }
+    const targetIds = (prev.targets ?? ["claude-code"]);
+    if (!opts.dryRun) {
+        for (const tId of targetIds) {
+            const spec = TARGETS[tId];
+            if (spec.skillFormat === "folder") {
+                const dst = join(spec.skillsDir, name);
+                if (existsSync(dst))
+                    rmSync(dst, { recursive: true, force: true });
+            }
+            else {
+                const ext = spec.skillFormat === "cursor-mdc" ? ".mdc" : ".md";
+                const dst = join(spec.skillsDir, `${name}${ext}`);
+                if (existsSync(dst))
+                    rmSync(dst, { force: true });
+            }
+        }
+        delete lock.skills[name];
+        writeLockFile(lock);
+    }
+    return { name, kind: "skill", status: "installed", targets: targetIds };
+}
+export function uninstallMcp(name, opts = {}) {
+    try {
+        validateMcpName(name);
+    }
+    catch (err) {
+        return {
+            name,
+            kind: "mcp",
+            status: "failed",
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+    const lock = readLockFile();
+    const prev = lock.mcps?.[name];
+    if (!prev || !lock.mcps) {
+        return { name, kind: "mcp", status: "skipped", error: "no estaba instalado" };
+    }
+    const targetIds = (prev.targets ?? ["claude-code"]);
+    if (!opts.dryRun) {
+        for (const tId of targetIds) {
+            unregisterMcpInTarget(name, TARGETS[tId]);
+        }
+        delete lock.mcps[name];
+        writeLockFile(lock);
+    }
+    return { name, kind: "mcp", status: "installed", targets: targetIds };
+}
+export function uninstallAll(opts = {}) {
+    const lock = readLockFile();
+    const results = [];
+    for (const name of Object.keys(lock.skills))
+        results.push(uninstallSkill(name, opts));
+    for (const name of Object.keys(lock.mcps ?? {}))
+        results.push(uninstallMcp(name, opts));
+    return results;
+}
+export function detectDrift(manifest) {
+    const lock = readLockFile();
+    const toInstall = [];
+    const toUpdate = [];
+    const unchanged = [];
+    const orphaned = [];
+    for (const name of Object.keys(manifest.skills)) {
+        const prev = lock.skills[name];
+        if (!prev) {
+            toInstall.push(name);
+            continue;
+        }
+        if (prev.bundleHash !== manifest.skills[name].bundleHash) {
+            toUpdate.push(name);
+        }
+        else {
+            unchanged.push(name);
+        }
+    }
+    for (const name of Object.keys(lock.skills)) {
+        if (!manifest.skills[name])
+            orphaned.push(name);
+    }
+    const mcps = {
+        toInstall: [],
+        toUpdate: [],
+        unchanged: [],
+        orphaned: [],
+    };
+    const manifestMcps = manifest.mcps ?? {};
+    for (const name of Object.keys(manifestMcps)) {
+        if (!lock.mcps?.[name])
+            mcps.toInstall.push(name);
+        else
+            mcps.unchanged.push(name);
+    }
+    for (const name of Object.keys(lock.mcps ?? {})) {
+        if (!manifestMcps[name])
+            mcps.orphaned.push(name);
+    }
+    return { toInstall, toUpdate, unchanged, orphaned, mcps };
+}
+export function summarize(results) {
+    let installed = 0;
+    let updated = 0;
+    let unchanged = 0;
+    let failed = 0;
+    let skipped = 0;
+    for (const r of results) {
+        if (r.status === "installed")
+            installed++;
+        else if (r.status === "updated")
+            updated++;
+        else if (r.status === "unchanged")
+            unchanged++;
+        else if (r.status === "failed")
+            failed++;
+        else if (r.status === "skipped")
+            skipped++;
+    }
+    process.stdout.write("\n");
+    if (installed > 0)
+        process.stdout.write(green(`  ✓ ${installed} instaladas\n`));
+    if (updated > 0)
+        process.stdout.write(green(`  ↻ ${updated} actualizadas\n`));
+    if (unchanged > 0)
+        process.stdout.write(gray(`  · ${unchanged} sin cambios\n`));
+    if (skipped > 0)
+        process.stdout.write(yellow(`  - ${skipped} omitidas\n`));
+    if (failed > 0)
+        process.stdout.write(red(`  ✗ ${failed} fallidas\n`));
+    for (const r of results) {
+        if (r.status === "failed") {
+            logError(`${r.name}: ${r.error}`);
+        }
+    }
+    process.stdout.write(dim(`  Lock: ${getLockFilePath()}\n`));
+    process.stdout.write("\n");
+}