codiedev 0.10.0-beta.4 → 0.10.0-beta.5

package/dist/packs/install.js

@@ -0,0 +1,285 @@
+"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 {
+            bySlug.set(slug, (0, codexHookTrust_1.packCodexHookTrustEntries)(hooksPath, JSON.parse(fs.readFileSync(hooksPath, "utf8"))));
+        }
+        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) };
+}

package/dist/packs/paths.js

@@ -0,0 +1,81 @@
+"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.MARKETPLACE_NAME = void 0;
+exports.packsRoot = packsRoot;
+exports.pluginsDir = pluginsDir;
+exports.pluginDir = pluginDir;
+exports.portableRoot = portableRoot;
+exports.marketplacePath = marketplacePath;
+exports.registryPath = registryPath;
+exports.shimPath = shimPath;
+exports.lastSyncPath = lastSyncPath;
+exports.statusCachePath = statusCachePath;
+exports.lastNagPath = lastNagPath;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+exports.MARKETPLACE_NAME = "codiedev-packs";
+function packsRoot(env = process.env, home = os.homedir()) {
+    const override = env.CODIEDEV_CONFIG_DIR?.trim();
+    const stateDir = override ? path.resolve(override) : path.join(home, ".codiedev");
+    return path.join(stateDir, "packs");
+}
+function pluginsDir(root) {
+    return path.join(root, "plugins");
+}
+function pluginDir(root, slug) {
+    return path.join(pluginsDir(root), slug);
+}
+function portableRoot(root) {
+    return path.join(root, "portable");
+}
+function marketplacePath(root) {
+    return path.join(root, ".claude-plugin", "marketplace.json");
+}
+function registryPath(root) {
+    return path.join(root, "installed.json");
+}
+function shimPath(root) {
+    return path.join(root, "codie-hook-shim.mjs");
+}
+function lastSyncPath(root) {
+    return path.join(root, ".last-sync");
+}
+function statusCachePath(root) {
+    return path.join(root, "status-cache.json");
+}
+function lastNagPath(root) {
+    return path.join(root, ".last-nag");
+}