codiedev 0.10.0-beta.1 → 0.10.0-beta.11

package/dist/packs/hookGate.js

@@ -0,0 +1,256 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_GATED_COMMAND_BYTES = void 0;
+exports.skillsFromPayload = skillsFromPayload;
+exports.encodeGatedCommand = encodeGatedCommand;
+exports.decodeGatedCommand = decodeGatedCommand;
+exports.parseGateArgs = parseGateArgs;
+exports.gateMatches = gateMatches;
+exports.splitShellOverride = splitShellOverride;
+exports.planShellCommand = planShellCommand;
+exports.planGateCommand = planGateCommand;
+exports.runHookGate = runHookGate;
+exports.runHookGateCli = runHookGateCli;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+function str(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+function parseMaybeJson(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+const SKILL_PATH = /[\\/]skills[\\/]([^\\/\s'"`;|&<>()]+)[\\/]SKILL\.md\b/g;
+function skillsInPath(text) {
+    return [...text.matchAll(SKILL_PATH)].map((m) => m[1]);
+}
+function stripPlugin(name) {
+    const index = name.lastIndexOf(":");
+    return index >= 0 ? name.slice(index + 1) : name;
+}
+function skillsFromPayload(payload) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        return [];
+    const p = payload;
+    const toolName = str(p.tool_name) ?? str(p.toolName) ?? "";
+    const rawInput = parseMaybeJson(p.tool_input ?? p.toolInput ?? p.toolArgs ?? p.input);
+    const input = rawInput && typeof rawInput === "object" && !Array.isArray(rawInput)
+        ? rawInput
+        : {};
+    const tool = toolName.toLowerCase();
+    if (tool === "skill") {
+        const name = str(input.skill) ?? str(input.name) ?? str(input.skill_name);
+        return name ? [stripPlugin(name.trim())] : [];
+    }
+    if (tool === "read" || tool === "view" || tool === "read_file") {
+        const file = str(input.file_path) ?? str(input.path) ?? str(input.filePath) ?? "";
+        return skillsInPath(file);
+    }
+    if (tool === "bash" || tool === "shell" || tool === "exec_command" || tool === "local_shell") {
+        const command = Array.isArray(input.command) ? input.command.join(" ") : str(input.command) ?? str(input.cmd) ?? "";
+        return skillsInPath(command);
+    }
+    return [];
+}
+exports.MAX_GATED_COMMAND_BYTES = 16 * 1024;
+function encodeGatedCommand(command) {
+    return Buffer.from(command, "utf8").toString("base64url");
+}
+function decodeGatedCommand(value) {
+    if (!/^[A-Za-z0-9_-]+$/.test(value) || value.length % 4 === 1)
+        throw new Error("--cmd-b64 is not base64url");
+    if (value.length > Math.ceil((exports.MAX_GATED_COMMAND_BYTES * 4) / 3) + 4)
+        throw new Error("--cmd-b64 command is over 16KB");
+    const bytes = Buffer.from(value, "base64url");
+    if (bytes.toString("base64url") !== value)
+        throw new Error("--cmd-b64 is not canonical base64url");
+    if (bytes.length > exports.MAX_GATED_COMMAND_BYTES)
+        throw new Error("--cmd-b64 command is over 16KB");
+    let text;
+    try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch {
+        throw new Error("--cmd-b64 command is not UTF-8");
+    }
+    if (text.includes("\u0000"))
+        throw new Error("--cmd-b64 command contains NUL");
+    if (!text.trim())
+        throw new Error("--cmd-b64 command is empty");
+    return text;
+}
+function parseGateArgs(argv) {
+    const sep = argv.indexOf("--");
+    const flags = sep >= 0 ? argv.slice(0, sep) : argv;
+    const command = sep >= 0 ? argv.slice(sep + 1) : [];
+    let skills = [];
+    let cmdB64;
+    for (let i = 0; i < flags.length; i++) {
+        const a = flags[i];
+        if (a === "--cmd-b64" || a.startsWith("--cmd-b64=")) {
+            cmdB64 = a === "--cmd-b64" ? flags[++i] ?? "" : a.slice("--cmd-b64=".length);
+            continue;
+        }
+        const value = a === "--skills" || a === "--skill" ? flags[++i] : a.startsWith("--skills=") ? a.slice(9) : undefined;
+        if (value === undefined)
+            throw new Error(`Unknown hook-gate argument: ${a}`);
+        skills.push(...value.split(",").map((s) => stripPlugin(s.trim())).filter(Boolean));
+    }
+    skills = [...new Set(skills)];
+    if (skills.length === 0)
+        throw new Error("hook-gate needs --skills a,b");
+    if (cmdB64 !== undefined && command.length)
+        throw new Error("hook-gate takes --cmd-b64 or -- <command>, not both");
+    if (cmdB64 === undefined && command.length === 0)
+        throw new Error("hook-gate needs --cmd-b64 <base64url> or -- <command>");
+    return { skills, command, ...(cmdB64 !== undefined ? { cmdB64 } : {}) };
+}
+function gateMatches(skills, payload) {
+    const running = skillsFromPayload(payload);
+    return running.some((name) => skills.includes(name));
+}
+function splitShellOverride(value) {
+    const out = [];
+    for (const m of value.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/g))
+        out.push(m[1] ?? m[2] ?? m[3]);
+    return out;
+}
+function shellFor(line, platform, env) {
+    const override = env.CODIEDEV_HOOK_SHELL?.trim();
+    if (override) {
+        const [file, ...args] = splitShellOverride(override);
+        if (file)
+            return { file, args: [...args, line] };
+    }
+    if (platform === "win32") {
+        return { file: env.ComSpec || env.COMSPEC || "cmd.exe", args: ["/d", "/s", "/c", `"${line}"`], verbatim: true };
+    }
+    return { file: "/bin/sh", args: ["-c", line] };
+}
+function planShellCommand(line, options = {}) {
+    return shellFor(line, options.platform ?? process.platform, options.env ?? process.env);
+}
+function planGateCommand(command, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const legacy = command.length === 3 && /^(?:\/bin\/)?sh(?:\.exe)?$/i.test(command[0]) && command[1] === "-c";
+    if (legacy && platform === "win32" && !(options.hasSh ?? (() => onPathSimple("sh", env, platform)))()) {
+        return { ...shellFor(command[2], platform, env), note: "codiedev hook-gate: sh isn't available; running the hook with cmd.exe instead\n" };
+    }
+    const [file, ...args] = command;
+    return { file, args };
+}
+function onPathSimple(bin, env, platform) {
+    const sep = platform === "win32" ? ";" : ":";
+    const exts = platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
+    for (const dir of (env.PATH ?? env.Path ?? "").split(sep).filter(Boolean)) {
+        for (const ext of exts) {
+            try {
+                if (fs.statSync(path.join(dir, bin + ext)).isFile())
+                    return true;
+            }
+            catch {
+            }
+        }
+    }
+    return false;
+}
+function runHookGate(argv, stdin, env = process.env, options = {}) {
+    let args;
+    try {
+        args = parseGateArgs(argv);
+    }
+    catch (error) {
+        process.stderr.write(`codiedev hook-gate: ${error.message}\n`);
+        return 0;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(stdin);
+    }
+    catch {
+        return 0;
+    }
+    if (!gateMatches(args.skills, payload))
+        return 0;
+    let plan;
+    if (args.cmdB64 !== undefined) {
+        let line;
+        try {
+            line = decodeGatedCommand(args.cmdB64);
+        }
+        catch (error) {
+            process.stderr.write(`codiedev hook-gate: ${error.message}; hook skipped\n`);
+            return 0;
+        }
+        plan = planShellCommand(line, { ...options, env });
+    }
+    else {
+        plan = planGateCommand(args.command, { ...options, env });
+    }
+    if (plan.note)
+        process.stderr.write(plan.note);
+    const result = (options.spawn ?? child_process_1.spawnSync)(plan.file, plan.args, {
+        input: stdin,
+        stdio: ["pipe", "inherit", "inherit"],
+        env,
+        windowsHide: true,
+        ...(plan.verbatim ? { windowsVerbatimArguments: true } : {}),
+    });
+    const ignoredStdin = result.error?.code === "EPIPE" && result.status !== null;
+    if (result.error && !ignoredStdin) {
+        process.stderr.write(`codiedev hook-gate: ${result.error.message}\n`);
+        return 1;
+    }
+    return result.status ?? 1;
+}
+function runHookGateCli(argv) {
+    let stdin = "";
+    try {
+        stdin = fs.readFileSync(0, "utf8");
+    }
+    catch {
+        stdin = "";
+    }
+    process.exitCode = runHookGate(argv, stdin);
+}

package/dist/packs/install.js

@@ -0,0 +1,286 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexPackHooksPath = codexPackHooksPath;
+exports.codexPackTrustEntries = codexPackTrustEntries;
+exports.installPacks = installPacks;
+exports.uninstallPacks = uninstallPacks;
+exports.formatUninstallLines = formatUninstallLines;
+exports.formatResultLines = formatResultLines;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const harnessDirs_1 = require("../harnessDirs");
+const codexHookTrust_1 = require("../codexHookTrust");
+const harnesses_1 = require("./harnesses");
+const manifest_1 = require("./manifest");
+const paths_1 = require("./paths");
+const shim_1 = require("./shim");
+const store_1 = require("./store");
+function marketplaceEntries(registry) {
+    return Object.entries(registry.packs).map(([slug, entry]) => ({
+        slug,
+        version: entry.version,
+        description: entry.description,
+    }));
+}
+function codexPackHooksPath(codexDir, slug, version) {
+    const base = path.join(codexDir, "plugins", "cache", paths_1.MARKETPLACE_NAME, slug);
+    const exact = path.join(base, (0, store_1.pluginVersion)(version), "hooks", "hooks.json");
+    if (fs.existsSync(exact))
+        return exact;
+    let best = null;
+    try {
+        for (const entry of fs.readdirSync(base)) {
+            const file = path.join(base, entry, "hooks", "hooks.json");
+            try {
+                const mtime = fs.statSync(file).mtimeMs;
+                if (!best || mtime > best.mtime)
+                    best = { file, mtime };
+            }
+            catch {
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return best?.file ?? null;
+}
+function codexPackTrustEntries(registry, codexDir) {
+    const bySlug = new Map();
+    for (const [slug, entry] of Object.entries(registry.packs).sort(([a], [b]) => a.localeCompare(b))) {
+        if (!entry.harnesses?.includes("codex"))
+            continue;
+        const hooksPath = codexPackHooksPath(codexDir, slug, entry.version);
+        if (!hooksPath)
+            continue;
+        try {
+            const plugin = { id: `${slug}@${paths_1.MARKETPLACE_NAME}`, root: path.dirname(path.dirname(hooksPath)) };
+            bySlug.set(slug, (0, codexHookTrust_1.packCodexHookTrustEntries)(hooksPath, JSON.parse(fs.readFileSync(hooksPath, "utf8")), plugin));
+        }
+        catch {
+        }
+    }
+    return bySlug;
+}
+function shimInputs(registry) {
+    const packs = [];
+    for (const [slug, entry] of Object.entries(registry.packs).sort(([a], [b]) => a.localeCompare(b))) {
+        if (!entry.harnesses?.includes("codie"))
+            continue;
+        try {
+            const parsed = JSON.parse(fs.readFileSync(path.join(entry.dir, "hooks", "hooks.json"), "utf8"));
+            if (parsed?.hooks && typeof parsed.hooks === "object")
+                packs.push({ slug, root: entry.dir, hooks: parsed.hooks });
+        }
+        catch {
+        }
+    }
+    return packs;
+}
+function installPacks(options) {
+    const env = options.env ?? process.env;
+    const home = options.home ?? os.homedir();
+    const run = options.run ?? (0, harnesses_1.defaultRunner)(env);
+    const now = options.now ?? Date.now;
+    const root = (0, paths_1.packsRoot)(env, home);
+    const selected = new Set(options.harnesses ?? harnesses_1.ADAPTERS.map((a) => a.name));
+    const adapters = harnesses_1.ADAPTERS.filter((a) => selected.has(a.name));
+    const registry = (0, store_1.readRegistry)(root);
+    const detected = new Map();
+    for (const adapter of adapters)
+        detected.set(adapter.name, adapter.detect({ root, env, home, run }));
+    const output = [];
+    for (const manifest of options.manifests) {
+        const dir = (0, paths_1.pluginDir)(root, manifest.slug);
+        const previous = registry.packs[manifest.slug];
+        const files = Object.keys((0, store_1.pluginFiles)(manifest)).sort();
+        const results = [];
+        if (options.dryRun) {
+            for (const adapter of adapters) {
+                const ctx = { root, env, home, run, manifest, pluginDir: dir, portablePluginDir: (0, paths_1.pluginDir)((0, paths_1.portableRoot)(root), manifest.slug), previous };
+                results.push(detected.get(adapter.name)
+                    ? { harness: adapter.name, status: "dry-run", detail: `would run: ${adapter.plan(ctx)}` }
+                    : { harness: adapter.name, status: "skipped", detail: "not detected" });
+            }
+            output.push({ slug: manifest.slug, version: manifest.version, contentHash: manifest.contentHash, dir, files, results, harnesses: [] });
+            continue;
+        }
+        (0, store_1.writePluginDir)(root, manifest);
+        (0, store_1.writePluginDir)((0, paths_1.portableRoot)(root), manifest, { portable: true });
+        const pending = {
+            packs: {
+                ...registry.packs,
+                [manifest.slug]: {
+                    version: manifest.version,
+                    contentHash: manifest.contentHash,
+                    dir,
+                    installedAt: previous?.installedAt ?? now(),
+                    harnesses: previous?.harnesses ?? [],
+                    name: manifest.name,
+                    description: manifest.description,
+                },
+            },
+        };
+        (0, store_1.writeMarketplace)(root, marketplaceEntries(pending));
+        (0, store_1.writeMarketplace)((0, paths_1.portableRoot)(root), marketplaceEntries(pending));
+        for (const adapter of adapters) {
+            if (!detected.get(adapter.name)) {
+                results.push({ harness: adapter.name, status: "skipped", detail: "not detected" });
+                continue;
+            }
+            try {
+                const detail = adapter.install({ root, env, home, run, manifest, pluginDir: dir, portablePluginDir: (0, paths_1.pluginDir)((0, paths_1.portableRoot)(root), manifest.slug), previous });
+                results.push({ harness: adapter.name, status: "ok", detail });
+            }
+            catch (error) {
+                results.push({ harness: adapter.name, status: "failed", detail: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        const kept = (previous?.harnesses ?? []).filter((h) => !selected.has(h));
+        const succeeded = results.filter((r) => r.status === "ok").map((r) => r.harness);
+        const harnesses = [...new Set([...kept, ...succeeded])].sort();
+        registry.packs[manifest.slug] = {
+            version: manifest.version,
+            contentHash: manifest.contentHash,
+            dir,
+            installedAt: now(),
+            harnesses,
+            name: manifest.name,
+            description: manifest.description,
+            ...(manifest.channel ? { channel: manifest.channel } : {}),
+            ...(manifest.icon ? { icon: manifest.icon } : {}),
+        };
+        (0, store_1.writeRegistry)(root, registry);
+        output.push({ slug: manifest.slug, ...(manifest.channel ? { channel: manifest.channel } : {}), version: manifest.version, contentHash: manifest.contentHash, dir, files, results, harnesses });
+    }
+    if (options.dryRun || options.manifests.length === 0)
+        return output;
+    if (selected.has("codex") && detected.get("codex")) {
+        const bySlug = regenerateCodexTrust(registry, env, home);
+        for (const pack of output) {
+            const codex = pack.results.find((r) => r.harness === "codex" && r.status === "ok");
+            const count = bySlug.get(pack.slug)?.length ?? 0;
+            if (codex && count)
+                codex.detail += `; ${count} hook${count === 1 ? "" : "s"} trusted`;
+        }
+    }
+    if (selected.has("codie")) {
+        (0, shim_1.writeShim)((0, paths_1.shimPath)(root), shimInputs(registry));
+        const skipped = (0, shim_1.unsupportedShimEvents)(shimInputs(registry));
+        for (const pack of output) {
+            const codie = pack.results.find((r) => r.harness === "codie" && r.status === "ok");
+            const events = skipped.get(pack.slug);
+            if (codie && events?.length)
+                codie.notes = [`hooks Codie can't run were skipped: ${events.join(", ")}`];
+        }
+    }
+    return output;
+}
+function regenerateCodexTrust(registry, env, home) {
+    const codexDir = (0, harnessDirs_1.codexHome)(env, home);
+    const bySlug = codexPackTrustEntries(registry, codexDir);
+    (0, codexHookTrust_1.writeCodexPackHookTrust)(path.join(codexDir, "config.toml"), [...bySlug.values()].flat());
+    return bySlug;
+}
+function uninstallPacks(options) {
+    const env = options.env ?? process.env;
+    const home = options.home ?? os.homedir();
+    const run = options.run ?? (0, harnesses_1.defaultRunner)(env);
+    const root = (0, paths_1.packsRoot)(env, home);
+    const registry = (0, store_1.readRegistry)(root);
+    const output = [];
+    for (const slug of options.slugs) {
+        const entry = registry.packs[slug];
+        if (!entry || !(0, manifest_1.isSafeSegment)(slug))
+            continue;
+        const results = [];
+        for (const adapter of harnesses_1.ADAPTERS) {
+            if (!entry.harnesses?.includes(adapter.name))
+                continue;
+            if (!adapter.detect({ root, env, home, run })) {
+                results.push({ harness: adapter.name, status: "skipped", detail: "not detected" });
+                continue;
+            }
+            try {
+                results.push({ harness: adapter.name, status: "ok", detail: adapter.uninstall({ root, env, home, run, slug }) });
+            }
+            catch (error) {
+                results.push({ harness: adapter.name, status: "failed", detail: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        delete registry.packs[slug];
+        fs.rmSync((0, paths_1.pluginDir)(root, slug), { recursive: true, force: true });
+        fs.rmSync((0, paths_1.pluginDir)((0, paths_1.portableRoot)(root), slug), { recursive: true, force: true });
+        output.push({ slug, results });
+    }
+    if (output.length === 0)
+        return output;
+    (0, store_1.writeRegistry)(root, registry);
+    (0, store_1.writeMarketplace)(root, marketplaceEntries(registry));
+    (0, store_1.writeMarketplace)((0, paths_1.portableRoot)(root), marketplaceEntries(registry));
+    const codexConfig = path.join((0, harnessDirs_1.codexHome)(env, home), "config.toml");
+    if (fs.existsSync(codexConfig))
+        regenerateCodexTrust(registry, env, home);
+    (0, shim_1.writeShim)((0, paths_1.shimPath)(root), shimInputs(registry));
+    return output;
+}
+function formatUninstallLines(results) {
+    const lines = [];
+    for (const pack of results) {
+        lines.push(`${pack.slug} removed (no longer assigned to your team)`);
+        for (const r of pack.results) {
+            const mark = r.status === "ok" ? "✓" : r.status === "failed" ? "✗" : "-";
+            lines.push(`  ${mark} ${r.harness}: ${r.status === "failed" ? "failed: " : r.status === "skipped" ? "skipped: " : ""}${r.detail}`);
+        }
+    }
+    return lines;
+}
+function formatResultLines(results) {
+    const lines = [];
+    for (const pack of results) {
+        lines.push(`${pack.slug} v${pack.version}${pack.channel ? ` (${pack.channel})` : ""} → ${pack.dir}`);
+        for (const r of pack.results) {
+            const mark = r.status === "ok" ? "✓" : r.status === "failed" ? "✗" : r.status === "dry-run" ? "·" : "-";
+            const word = r.status === "ok" ? "" : r.status === "failed" ? "failed: " : r.status === "skipped" ? "skipped: " : "";
+            lines.push(`  ${mark} ${r.harness}: ${word}${r.detail}`);
+            if (process.env.CODIEDEV_DEBUG)
+                for (const note of r.notes ?? [])
+                    lines.push(`      note: ${note}`);
+        }
+    }
+    return lines;
+}

package/dist/packs/manifest.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManifestError = void 0;
+exports.isSafeSegment = isSafeSegment;
+exports.isSafeSkillName = isSafeSkillName;
+exports.parseManifest = parseManifest;
+exports.cleanLabel = cleanLabel;
+exports.displayName = displayName;
+exports.parseFrontmatter = parseFrontmatter;
+const SAFE_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function isSafeSegment(value) {
+    return typeof value === "string" && SAFE_SEGMENT.test(value) && !value.includes("..");
+}
+const SAFE_SKILL_NAME = /^[A-Za-z0-9][A-Za-z0-9._ -]{0,127}$/;
+function isSafeSkillName(value) {
+    return typeof value === "string" && SAFE_SKILL_NAME.test(value) && !value.includes("..") && value.trim() === value;
+}
+class ManifestError extends Error {
+}
+exports.ManifestError = ManifestError;
+function fileList(value, field, safe) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value))
+        throw new ManifestError(`manifest.${field} must be an array`);
+    const seen = new Set();
+    return value.map((item, index) => {
+        const entry = item;
+        if (!entry || typeof entry !== "object")
+            throw new ManifestError(`manifest.${field}[${index}] is not an object`);
+        if (!safe(entry.name)) {
+            throw new ManifestError(`manifest.${field}[${index}] has an unsafe name: ${JSON.stringify(entry.name)}`);
+        }
+        if (typeof entry.content !== "string")
+            throw new ManifestError(`manifest.${field}[${index}].content must be a string`);
+        const key = entry.name.toLowerCase();
+        if (seen.has(key))
+            throw new ManifestError(`manifest.${field} has a duplicate name: ${entry.name}`);
+        seen.add(key);
+        const artifactId = typeof entry.artifactId === "string" && /^[a-z0-9]{16,64}$/i.test(entry.artifactId) ? entry.artifactId : undefined;
+        return { name: entry.name, content: entry.content, ...(artifactId ? { artifactId } : {}) };
+    });
+}
+function parseManifest(input) {
+    let raw = input;
+    if (typeof raw === "string") {
+        try {
+            raw = JSON.parse(raw);
+        }
+        catch {
+            throw new ManifestError("manifest is not valid JSON");
+        }
+    }
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        throw new ManifestError("manifest is not an object");
+    const m = raw;
+    if (!isSafeSegment(m.slug))
+        throw new ManifestError(`manifest has an unsafe slug: ${JSON.stringify(m.slug)}`);
+    const version = Number(m.version);
+    if (!Number.isInteger(version) || version < 0)
+        throw new ManifestError("manifest.version must be a non-negative integer");
+    if (typeof m.contentHash !== "string" || !m.contentHash)
+        throw new ManifestError("manifest.contentHash is missing");
+    let hooksJson = null;
+    if (m.hooksJson !== undefined && m.hooksJson !== null) {
+        if (typeof m.hooksJson !== "string")
+            throw new ManifestError("manifest.hooksJson must be a string or null");
+        if (m.hooksJson.trim()) {
+            let parsed;
+            try {
+                parsed = JSON.parse(m.hooksJson);
+            }
+            catch {
+                throw new ManifestError("manifest.hooksJson is not valid JSON");
+            }
+            const hooks = parsed?.hooks;
+            if (!hooks || typeof hooks !== "object" || Array.isArray(hooks)) {
+                throw new ManifestError("manifest.hooksJson must look like {\"hooks\":{...}}");
+            }
+            hooksJson = m.hooksJson;
+        }
+    }
+    return {
+        slug: m.slug,
+        name: typeof m.name === "string" && m.name ? m.name : m.slug,
+        description: typeof m.description === "string" ? m.description : "",
+        version,
+        contentHash: m.contentHash,
+        skills: fileList(m.skills, "skills", isSafeSkillName),
+        agents: fileList(m.agents, "agents", isSafeSegment),
+        hooksJson,
+        ...(cleanLabel(m.channel, 16) ? { channel: cleanLabel(m.channel, 16) } : {}),
+        ...(cleanLabel(m.icon, 16) ? { icon: cleanLabel(m.icon, 16) } : {}),
+    };
+}
+function cleanLabel(value, max) {
+    if (typeof value !== "string")
+        return undefined;
+    const clean = value
+        .replace(/\u001b\[[0-9;?]*[ -\/]*[@-~]/g, "")
+        .replace(/[\u0000-\u001f\u007f-\u009f]/g, "")
+        .trim();
+    return clean ? [...clean].slice(0, max).join("") : undefined;
+}
+function displayName(pack) {
+    const icon = cleanLabel(pack.icon, 8);
+    const name = pack.name || pack.slug;
+    return icon ? `${icon} ${name}` : name;
+}
+function parseFrontmatter(content) {
+    const match = content.match(/^?---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/);
+    if (!match)
+        return { data: {}, body: content };
+    const data = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const kv = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
+        if (!kv)
+            continue;
+        let value = kv[2].trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        data[kv[1]] = value;
+    }
+    return { data, body: content.slice(match[0].length) };
+}