howtofixcli 0.7.8 → 0.7.9

package/dist/presets.js

@@ -1,727 +0,0 @@
-/**
- * Presets: developer-provided bundles of skills and prompt text.
- *
- * A preset is a directory holding a `preset.json` manifest, a `skills/` tree and
- * an optional `prompt.md`. It is never installed on its own. Registering a skill
- * puts its name and description into the system prompt of every request, so a
- * preset is a catalogue entry the user opts into — not something that arrives
- * with the install and quietly makes every request heavier.
- *
- * Nothing here executes anything from a preset. A preset is text: instructions
- * the model reads. The only side effect of installing one is copying files into
- * a directory this module owns, after checking that every path stays inside the
- * preset it came from.
- *
- * Two sources feed the catalogue:
- *
- *   - bundled  — the suite shipped with the package (`presets/` at the package
- *                root, copied to `dist/presets/` by both build paths). These are
- *                the developer-provided presets.
- *   - installed — what the user has opted into, under `AGENT_DIR/presets` and
- *                `<cwd>/.howtofix/presets`.
- */
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import { AGENT_DIR } from "./paths.js";
-import { validateMcpBlock } from "./preset-mcp.js";
-import { isSafeRelativePath, parseTarGz, subtreeEntries } from "./tar.js";
-/** User-global install root. */
-export function userPresetsDir() {
-    return join(AGENT_DIR, "presets");
-}
-/** Project-scoped install root. */
-export function projectPresetsDir(cwd) {
-    return join(cwd, ".howtofix", "presets");
-}
-/** Integration presets stay dormant until the user explicitly enables them. */
-export function isPresetDisabled(dir) {
-    return existsSync(join(dir, ".disabled"));
-}
-/**
- * The preset suite bundled with this install (`presets/` at the package root,
- * copied to `dist/presets/`).
- *
- * Resolved from `import.meta.url` for the same reason `bundledAssetsDir` is: at
- * runtime the working directory is the user's project, which has none of our
- * assets in it.
- */
-export function bundledPresetsDir() {
-    return join(dirname(fileURLToPath(import.meta.url)), "presets");
-}
-/** Both install roots, in load order: project first, then user-global. */
-export function presetRoots(cwd) {
-    return [projectPresetsDir(cwd), userPresetsDir()];
-}
-const NAME_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
-const SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
- * Check that `child` resolves inside `root`.
- *
- * The whole point of a preset is that it is a self-contained directory of text.
- * A manifest naming `../../.ssh` would copy a user's keys into a skill tree and
- * hand them to the model on the next call, so every path a manifest contributes
- * is resolved and compared against the preset root before it is used.
- */
-function insideRoot(root, child) {
-    const rel = relative(resolve(root), resolve(child));
-    return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
-}
-/**
- * Validate a manifest and its referenced files.
- *
- * Returns every problem rather than the first, so a preset author sees the whole
- * list in one run instead of fixing them one per attempt.
- */
-export function validatePreset(dir, value) {
-    const problems = [];
-    if (!isRecord(value))
-        return ["preset.json must be a JSON object"];
-    const str = (key) => {
-        const raw = value[key];
-        if (typeof raw !== "string" || raw.trim() === "") {
-            problems.push(`${key} must be a non-empty string`);
-            return "";
-        }
-        return raw.trim();
-    };
-    const name = str("name");
-    const title = str("title");
-    const description = str("description");
-    const category = str("category");
-    const version = str("version");
-    if (name && !NAME_PATTERN.test(name)) {
-        problems.push(`name "${name}" must be lowercase letters, digits and dashes`);
-    }
-    if (version && !SEMVER_PATTERN.test(version)) {
-        problems.push(`version "${version}" is not a version like 1.0.0`);
-    }
-    const rawSkills = value.skills;
-    if (!Array.isArray(rawSkills) || rawSkills.length === 0) {
-        problems.push("skills must be a non-empty array of directory names");
-    }
-    else {
-        for (const entry of rawSkills) {
-            if (typeof entry !== "string" || entry.trim() === "") {
-                problems.push("every skills entry must be a non-empty string");
-                continue;
-            }
-            const skillDir = join(dir, "skills", entry.trim());
-            if (!insideRoot(join(dir, "skills"), skillDir)) {
-                problems.push(`skill "${entry}" escapes the preset directory`);
-                continue;
-            }
-            if (!existsSync(join(skillDir, "SKILL.md"))) {
-                problems.push(`skill "${entry}" has no SKILL.md at ${join("skills", entry)}`);
-            }
-        }
-    }
-    const rawPrompt = value.prompt;
-    if (rawPrompt !== undefined) {
-        if (typeof rawPrompt !== "string" || rawPrompt.trim() === "") {
-            problems.push("prompt must be a non-empty string when present");
-        }
-        else {
-            const promptPath = join(dir, rawPrompt.trim());
-            if (!insideRoot(dir, promptPath)) {
-                problems.push(`prompt "${rawPrompt}" escapes the preset directory`);
-            }
-            else if (!existsSync(promptPath)) {
-                problems.push(`prompt file "${rawPrompt}" does not exist`);
-            }
-        }
-    }
-    const rawTags = value.tags;
-    if (rawTags !== undefined && !Array.isArray(rawTags)) {
-        problems.push("tags must be an array when present");
-    }
-    problems.push(...validateMcpBlock(value.mcp));
-    return problems;
-}
-/** Read and validate one preset directory. */
-export function readPreset(dir) {
-    const manifestPath = join(dir, "preset.json");
-    if (!existsSync(manifestPath))
-        return { problems: [`no preset.json in ${dir}`] };
-    let parsed;
-    try {
-        parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
-    }
-    catch (err) {
-        return { problems: [`preset.json is not valid JSON: ${err instanceof Error ? err.message : String(err)}`] };
-    }
-    const problems = validatePreset(dir, parsed);
-    if (problems.length > 0)
-        return { problems };
-    const record = parsed;
-    const tags = Array.isArray(record.tags) ? record.tags.filter((t) => typeof t === "string") : [];
-    return {
-        problems: [],
-        manifest: {
-            name: String(record.name),
-            title: String(record.title),
-            description: String(record.description),
-            category: String(record.category),
-            tags,
-            version: String(record.version),
-            skills: record.skills.map((s) => String(s)),
-            prompt: typeof record.prompt === "string" ? record.prompt : undefined,
-            mcp: record.mcp && typeof record.mcp === "object" && !Array.isArray(record.mcp) ? record.mcp : undefined,
-            integrates: typeof record.integrates === "string" && record.integrates.trim() !== "" ? record.integrates.trim() : undefined,
-        },
-    };
-}
-/** Directories that may hold presets, ignoring ones that are missing. */
-function existingDirs(roots) {
-    return roots.filter((root) => {
-        try {
-            return statSync(root).isDirectory();
-        }
-        catch {
-            return false;
-        }
-    });
-}
-/**
- * Walk one root and read every preset under it.
- *
- * Two layouts are supported, because the catalogue and an install do not have the
- * same shape: the bundled suite groups presets by category
- * (`<root>/<category>/<name>/`), while an install lands directly under the root
- * (`<root>/<name>/`) — a category in the install path would be a second copy of
- * the manifest's own `category` field, free to disagree with it. A directory that
- * fails to validate is reported, not silently dropped: a broken preset that
- * vanishes from the menu is indistinguishable from one that was never installed.
- */
-function scanRoot(root, source) {
-    const entries = [];
-    const problems = [];
-    const readOne = (dir, label) => {
-        if (!existsSync(join(dir, "preset.json")))
-            return;
-        const { manifest, problems: issues } = readPreset(dir);
-        if (manifest)
-            entries.push({ manifest, dir, source });
-        else
-            problems.push(`${label}: ${issues.join("; ")}`);
-    };
-    // The root can disappear between the `isDirectory()` guard and this read — a
-    // removal in another session, a cleanup — and an ENOENT thrown here would take
-    // down whatever asked for the catalogue. A missing root is an empty catalogue.
-    let firstLevel;
-    try {
-        firstLevel = readdirSync(root).sort();
-    }
-    catch {
-        return { entries, problems };
-    }
-    for (const first of firstLevel) {
-        // A dot-entry is never a preset: the install lock and an in-progress staging
-        // directory both live here, and a staging directory holds a `preset.json` —
-        // so without this it would be catalogued as a preset that exists only while
-        // another install is running, and the menu would list a name that vanishes.
-        if (first.startsWith("."))
-            continue;
-        const firstDir = join(root, first);
-        try {
-            if (!statSync(firstDir).isDirectory())
-                continue;
-        }
-        catch {
-            continue;
-        }
-        // Flat layout: the preset is this directory.
-        if (existsSync(join(firstDir, "preset.json"))) {
-            readOne(firstDir, first);
-            continue;
-        }
-        // Grouped layout: `<category>/<name>/`.
-        let names;
-        try {
-            names = readdirSync(firstDir).sort();
-        }
-        catch {
-            continue;
-        }
-        for (const name of names) {
-            if (name.startsWith("."))
-                continue;
-            const dir = join(firstDir, name);
-            try {
-                if (!statSync(dir).isDirectory())
-                    continue;
-            }
-            catch {
-                continue;
-            }
-            readOne(dir, join(first, name));
-        }
-    }
-    return { entries, problems };
-}
-/** The full catalogue: bundled presets plus everything installed. */
-export function listCatalog(cwd) {
-    const bundled = scanRoot(bundledPresetsDir(), "bundled");
-    const entries = [...bundled.entries];
-    const problems = [...bundled.problems];
-    // An installed preset of the same name replaces the bundled one: opting into a
-    // preset and then editing it locally must not be silently overridden by the
-    // copy that ships with the package.
-    const seen = new Map(entries.map((entry) => [entry.manifest.name, entry]));
-    for (const root of existingDirs(presetRoots(cwd))) {
-        const scanned = scanRoot(root, "installed");
-        problems.push(...scanned.problems);
-        for (const entry of scanned.entries) {
-            const previous = seen.get(entry.manifest.name);
-            if (previous) {
-                const index = entries.indexOf(previous);
-                if (index >= 0)
-                    entries[index] = entry;
-                seen.set(entry.manifest.name, entry);
-            }
-            else {
-                entries.push(entry);
-                seen.set(entry.manifest.name, entry);
-            }
-        }
-    }
-    return { entries, problems };
-}
-/** Category names present in the catalogue, sorted. */
-export function categoriesOf(entries) {
-    return [...new Set(entries.map((entry) => entry.manifest.category))].sort();
-}
-/** Presets in one category, sorted by title. */
-export function presetsIn(entries, category) {
-    return entries.filter((entry) => entry.manifest.category === category).sort((a, b) => a.manifest.title.localeCompare(b.manifest.title));
-}
-/**
- * Skill directories contributed by installed presets.
- *
- * Returned as search paths for the SDK resource loader, which scans a directory
- * for skill subdirectories. Only *installed* presets contribute: a bundled preset
- * that was never opted into must not put its skills into the prompt.
- */
-export function installedPresetSkillPaths(cwd) {
-    const paths = [];
-    for (const root of existingDirs(presetRoots(cwd))) {
-        const { entries } = scanRoot(root, "installed");
-        for (const entry of entries)
-            if (!isPresetDisabled(entry.dir))
-                paths.push(join(entry.dir, "skills"));
-    }
-    return paths;
-}
-/**
- * Prompt text contributed by installed presets.
- *
- * A preset's `prompt.md` is appended to the system prompt as its own section. It
- * is never allowed to replace the prompt: a preset that could rewrite the rules
- * could remove the ones that keep it honest.
- */
-export function installedPresetPrompts(cwd) {
-    const out = [];
-    for (const root of existingDirs(presetRoots(cwd))) {
-        const { entries } = scanRoot(root, "installed");
-        for (const entry of entries) {
-            if (isPresetDisabled(entry.dir))
-                continue;
-            const rel = entry.manifest.prompt;
-            if (!rel)
-                continue;
-            const file = join(entry.dir, rel);
-            if (!insideRoot(entry.dir, file))
-                continue;
-            try {
-                const text = readFileSync(file, "utf8").trim();
-                if (text)
-                    out.push({ name: entry.manifest.name, title: entry.manifest.title, text });
-            }
-            catch {
-                // A prompt file that disappeared between validation and read is a missing
-                // section, not a failed session.
-            }
-        }
-    }
-    return out;
-}
-/** Total bytes of a preset's skills, for the "how much does this cost" line. */
-export function presetSize(dir, manifest) {
-    let total = 0;
-    for (const skill of manifest.skills) {
-        try {
-            total += statSync(join(dir, "skills", skill, "SKILL.md")).size;
-        }
-        catch {
-            // Missing files were already reported by validation.
-        }
-    }
-    return total;
-}
-/**
- * Sleep without yielding, for the synchronous install path.
- *
- * `copyPreset` is synchronous, so it cannot await a timer. `Atomics.wait` on a
- * shared buffer is the one way to block the current thread for a fixed time
- * without spinning a core.
- */
-function sleepSync(ms) {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-/** Name of the lock that serialises installs across processes. */
-const INSTALL_LOCK = ".install.lock";
-/**
- * Run `body` while holding the install lock for `targetRoot`.
- *
- * The in-process `presetBusy` flag stops one CLI from racing itself, but nothing
- * stopped two sessions — or a session and a script — from installing into the
- * same project at the same time. That is a real collision: the swap below removes
- * a directory and renames another into its place, and a second process doing the
- * same between those two steps leaves a project with no preset, or with one
- * process's files where the other's should be.
- *
- * A lock file rather than a directory: `wx` is atomic on every filesystem this
- * runs on, and the pid inside makes a stuck lock diagnosable. A lock older than
- * two minutes is treated as abandoned and taken over — a killed process must not
- * wedge installs until someone deletes a file by hand.
- */
-function withInstallLock(targetRoot, body) {
-    mkdirSync(targetRoot, { recursive: true });
-    const lockPath = join(targetRoot, INSTALL_LOCK);
-    const deadline = Date.now() + 60_000;
-    for (;;) {
-        try {
-            writeFileSync(lockPath, `${process.pid}\n`, { flag: "wx" });
-            break;
-        }
-        catch (err) {
-            if (err.code !== "EEXIST")
-                throw err;
-            let stale = false;
-            try {
-                stale = Date.now() - statSync(lockPath).mtimeMs > 120_000;
-            }
-            catch {
-                // The holder released it between the failed create and this stat. Retry.
-                continue;
-            }
-            if (stale) {
-                rmSync(lockPath, { force: true });
-                continue;
-            }
-            if (Date.now() > deadline) {
-                throw new Error(`another install is holding ${lockPath}; remove it if no install is running`);
-            }
-            sleepSync(100);
-        }
-    }
-    try {
-        // Clean up staging directories left by an install that was killed. They are
-        // only safe to remove while holding the lock — another install may be using
-        // its own right now — and they are never collected otherwise, so a few
-        // crashed installs would otherwise accumulate megabytes in the project.
-        for (const name of readdirSync(targetRoot)) {
-            if (!name.startsWith(".staging-"))
-                continue;
-            rmSync(join(targetRoot, name), { recursive: true, force: true });
-        }
-        return body();
-    }
-    finally {
-        rmSync(lockPath, { force: true });
-    }
-}
-/**
- * Put `sourceDir` at `targetRoot/<name>`, replacing whatever is there.
- *
- * Staged and renamed rather than removed and copied. The previous version did
- * `rmSync(target)` then `cpSync(source, target)`, and between those two calls the
- * preset did not exist — a reader in that window (a reload, a second session
- * starting) saw a project with no preset, and a crash left it that way. It also
- * let two concurrent installs interleave: A removes, B removes, A copies, B
- * copies, and the result is a mix of both.
- *
- * The staging directory is created *inside* `targetRoot` so the rename stays on
- * one filesystem, where it is atomic. It is named with a leading dot, and the
- * catalogue scan skips dot-entries, so a staging directory in progress is never
- * mistaken for an installed preset.
- */
-function copyPreset(sourceDir, targetRoot, manifest) {
-    const target = join(targetRoot, manifest.name);
-    return withInstallLock(targetRoot, () => {
-        mkdirSync(targetRoot, { recursive: true });
-        const staging = mkdtempSync(join(targetRoot, ".staging-"));
-        try {
-            cpSync(sourceDir, staging, { recursive: true });
-            // Replace rather than merge: a reinstall must not leave a skill from the
-            // previous version behind, where it would keep loading with no file on disk
-            // that explains where it came from.
-            rmSync(target, { recursive: true, force: true });
-            renameSync(staging, target);
-        }
-        catch (err) {
-            rmSync(staging, { recursive: true, force: true });
-            throw err;
-        }
-        return target;
-    });
-}
-/** Install a preset from a local directory. */
-export function installFromDirectory(sourceDir, targetRoot) {
-    if (!existsSync(sourceDir))
-        return { ok: false, problems: [`no such directory: ${sourceDir}`] };
-    const { manifest, problems } = readPreset(sourceDir);
-    if (!manifest)
-        return { ok: false, problems };
-    const target = copyPreset(sourceDir, targetRoot, manifest);
-    return { ok: true, name: manifest.name, target, problems: [] };
-}
-/**
- * Install a preset from a git URL.
- *
- * A shallow clone into a temporary directory, then the same validation a local
- * directory gets. The clone is what makes this safe to accept from a URL: the
- * repository is data to be read, never a program to be run — no install hooks,
- * no post-checkout script, nothing executed from the checkout.
- */
-export function installFromGit(url, targetRoot) {
-    const staging = mkdtempSync(join(tmpdir(), "howtofix-preset-"));
-    try {
-        execFileSync("git", ["clone", "--depth", "1", "--quiet", url, staging], { stdio: "pipe" });
-        return installFromDirectory(staging, targetRoot);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { ok: false, problems: [`git clone failed: ${message.split("\n")[0]}`] };
-    }
-    finally {
-        rmSync(staging, { recursive: true, force: true });
-    }
-}
-/** Install from a git URL or a local path, whichever the argument looks like. */
-export function installFrom(source, targetRoot) {
-    const looksLikeGit = /^(https?:\/\/|git@|git:\/\/)/.test(source);
-    return looksLikeGit ? installFromGit(source, targetRoot) : installFromDirectory(resolve(source), targetRoot);
-}
-/**
- * Remove an installed preset.
- *
- * Only from the install roots — a bundled preset is part of the package and is
- * "removed" by never opting into it. Returns the paths that were removed.
- */
-export function removeInstalled(name, cwd) {
-    const removed = [];
-    const problems = [];
-    if (!NAME_PATTERN.test(name))
-        return { removed, problems: [`"${name}" is not a preset name`] };
-    for (const root of presetRoots(cwd)) {
-        const target = join(root, name);
-        if (!existsSync(target))
-            continue;
-        if (!insideRoot(root, target)) {
-            problems.push(`refusing to remove ${target}: outside ${root}`);
-            continue;
-        }
-        rmSync(target, { recursive: true, force: true });
-        removed.push(target);
-    }
-    if (removed.length === 0)
-        problems.push(`"${name}" is not installed`);
-    return { removed, problems };
-}
-/** Where a new install should land: the project root when there is one. */
-export function defaultInstallRoot(cwd) {
-    return projectPresetsDir(cwd);
-}
-/** Digest of a directory tree: sha256 over `hash  path` lines, sorted by path. */
-export function treeDigest(dir) {
-    const files = [];
-    const walk = (d, prefix) => {
-        for (const entry of readdirSync(d, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-            const p = join(d, entry.name);
-            const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-            // Symlinks are skipped: a clone resolves them, a tarball records a link
-            // entry, and hashing one side only would report a permanent mismatch.
-            if (entry.isSymbolicLink())
-                continue;
-            if (entry.isDirectory())
-                walk(p, rel);
-            else if (entry.isFile())
-                files.push([rel, createHash("sha256").update(readFileSync(p)).digest("hex")]);
-        }
-    };
-    walk(dir, "");
-    let bytes = 0;
-    for (const [rel] of files)
-        bytes += statSync(join(dir, rel)).size;
-    const manifest = files.map(([rel, hash]) => `${hash}  ${rel}`).join("\n");
-    return {
-        digest: createHash("sha256").update(manifest).digest("hex").slice(0, 16),
-        fileCount: files.length,
-        bytes,
-    };
-}
-/** Read the bundled registry. A missing or malformed file is an empty list, not a crash. */
-export function readHub() {
-    const file = join(bundledPresetsDir(), "hub.json");
-    try {
-        const raw = readFileSync(file, "utf8");
-        const parsed = JSON.parse(raw);
-        const list = isRecord(parsed) && Array.isArray(parsed.entries) ? parsed.entries : [];
-        const entries = [];
-        for (const item of list) {
-            if (!isRecord(item))
-                continue;
-            if (typeof item.name !== "string" || typeof item.repo !== "string" || typeof item.sha !== "string")
-                continue;
-            if (typeof item.path !== "string" || typeof item.category !== "string")
-                continue;
-            entries.push({
-                name: item.name,
-                title: typeof item.title === "string" ? item.title : item.name,
-                description: typeof item.description === "string" ? item.description : "",
-                category: item.category,
-                skill: typeof item.skill === "string" ? item.skill : item.name,
-                path: item.path,
-                repo: item.repo,
-                sha: item.sha,
-                license: typeof item.license === "string" ? item.license : "unknown",
-                stars: typeof item.stars === "number" ? item.stars : 0,
-                sizeKb: typeof item.sizeKb === "number" ? item.sizeKb : 0,
-                // Carried through, not dropped: the install verifies this against what it
-                // downloads, and an entry whose digest is silently discarded would look
-                // verified while checking nothing.
-                ...(typeof item.digest === "string" ? { digest: item.digest } : {}),
-                ...(typeof item.fileCount === "number" ? { fileCount: item.fileCount } : {}),
-                // Carried explicitly: this builder names every field, so a field added to
-                // the generator and forgotten here is dropped silently and the registry
-                // looks complete while saying nothing. That happened once with `digest`.
-                ...(typeof item.modelInvocable === "boolean" ? { modelInvocable: item.modelInvocable } : {}),
-            });
-        }
-        return { entries, problems: [] };
-    }
-    catch (err) {
-        if (err?.code === "ENOENT")
-            return { entries: [], problems: [] };
-        return { entries: [], problems: [`registry unreadable: ${err instanceof Error ? err.message : String(err)}`] };
-    }
-}
-/** Entries of the registry, grouped for the menu. */
-export function hubCategories(entries) {
-    return [...new Set(entries.map((e) => e.category))].sort();
-}
-export function hubIn(entries, category) {
-    return entries.filter((e) => e.category === category).sort((a, b) => b.stars - a.stars || a.name.localeCompare(b.name));
-}
-export function hubFind(entries, name) {
-    return entries.find((e) => e.name === name);
-}
-/** Where a downloaded tarball for an entry comes from. */
-export function hubTarballUrl(entry) {
-    return `https://codeload.github.com/${entry.repo}/tar.gz/${entry.sha}`;
-}
-/**
- * Download and install a registry entry.
- *
- * The archive is treated as data: entries are read, each path is checked against
- * the destination, and nothing in it is executed. The pinned `sha` means the
- * bytes are the ones the registry was built from, not whatever upstream has
- * pushed since.
- *
- * The timeout is 120s rather than 60s because the largest entry in the registry
- * is a 24 MB archive, and a timeout that a supported entry cannot meet turns a
- * slow connection into "this preset is broken".
- */
-export async function installFromHub(entry, targetRoot, timeoutMs = 120_000) {
-    const staging = mkdtempSync(join(tmpdir(), "howtofix-hub-"));
-    try {
-        const response = await fetch(hubTarballUrl(entry), {
-            signal: AbortSignal.timeout(timeoutMs),
-            redirect: "follow",
-        });
-        if (!response.ok) {
-            return { ok: false, problems: [`${entry.repo}: HTTP ${response.status} from codeload`] };
-        }
-        const archive = Buffer.from(await response.arrayBuffer());
-        const entries = parseTarGz(archive);
-        const files = subtreeEntries(entries, entry.path).filter((e) => e.kind === "file" || e.kind === "directory");
-        if (!files.some((e) => e.path === "SKILL.md")) {
-            return { ok: false, problems: [`${entry.repo}@${entry.sha.slice(0, 7)} has no ${entry.path}/SKILL.md`] };
-        }
-        // Write into staging as `<preset>/skills/<skill>/…`, which is the layout a
-        // preset directory has, so the same validation and the same install path run
-        // for a downloaded preset as for a local one.
-        const presetDir = join(staging, "preset", entry.name);
-        const skillRoot = join(presetDir, "skills", entry.skill);
-        let written = 0;
-        for (const file of files) {
-            if (!isSafeRelativePath(file.path)) {
-                return { ok: false, problems: [`refusing unsafe path in archive: ${file.path}`] };
-            }
-            const destination = join(skillRoot, file.path);
-            if (!insideRoot(skillRoot, destination)) {
-                return { ok: false, problems: [`refusing path outside the skill: ${file.path}`] };
-            }
-            if (file.kind === "directory") {
-                mkdirSync(destination, { recursive: true });
-                continue;
-            }
-            mkdirSync(dirname(destination), { recursive: true });
-            writeFileSync(destination, file.data ?? Buffer.alloc(0));
-            written += 1;
-        }
-        const manifest = {
-            name: entry.name,
-            title: entry.title,
-            description: entry.description,
-            category: entry.category,
-            version: "1.0.0",
-            skills: [entry.skill],
-            source: `${entry.repo}@${entry.sha}`,
-            license: entry.license,
-        };
-        writeFileSync(join(presetDir, "preset.json"), `${JSON.stringify(manifest, null, 2)}\n`);
-        // Verify what actually arrived against what the registry recorded. The `sha`
-        // already pins the commit; this catches the other case — the commit is still
-        // reachable but the skill's composition under it is not what was reviewed.
-        // Every registry entry carries a digest (build-preset-hub.mjs writes one
-        // for all 911); an entry without it cannot be verified against what was
-        // reviewed, so it is refused rather than installed unchecked.
-        if (!entry.digest) {
-            return {
-                ok: false,
-                problems: [`${entry.repo}@${entry.sha.slice(0, 7)}: registry entry has no digest`, "refusing to install; content cannot be verified against what was reviewed"],
-            };
-        }
-        const actual = treeDigest(skillRoot);
-        if (actual.digest !== entry.digest) {
-            return {
-                ok: false,
-                problems: [
-                    `${entry.repo}@${entry.sha.slice(0, 7)}: content changed under a pinned commit`,
-                    `expected ${entry.digest} (${entry.fileCount ?? "?"} files), got ${actual.digest} (${actual.fileCount} files)`,
-                    "refusing to install; the registry needs regenerating",
-                ],
-            };
-        }
-        const problems = validatePreset(presetDir, manifest);
-        if (problems.length > 0)
-            return { ok: false, problems };
-        const target = copyPreset(presetDir, targetRoot, manifest);
-        return { ok: true, name: entry.name, target, problems: [], skill: entry.skill, modelInvocable: entry.modelInvocable };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { ok: false, problems: [`download failed: ${message.split("\n")[0]}`] };
-    }
-    finally {
-        rmSync(staging, { recursive: true, force: true });
-    }
-}