codiedev 0.9.67 → 0.9.69

package/dist/packs/hookGate.js

@@ -0,0 +1,289 @@
+"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;
+// `codiedev hook-gate --skills a,b --cmd-b64 <base64url>`: run a pack hook only
+// while one of the named skills is in use. Reads the harness hook payload on
+// stdin, passes it through to the command unchanged, and exits with its status
+// (including 2 = block). No match / unreadable payload → exit 0, no output.
+// Also accepted: `-- <argv…>` (exec'd directly) and the legacy
+// `-- sh -c '<cmd>'` form saved by earlier pack editors.
+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;
+}
+/** Skill names a hook payload shows as running, across the five tools:
+ * - Claude:  tool_name "Skill",  tool_input.skill "<plugin>:<name>"
+ * - Copilot: tool_name "skill",  tool_input.skill "<name>" (also camelCase toolName/toolArgs)
+ * - Codie:   tool_name "skill",  tool_input.name "<name>"
+ * - Cursor:  tool_name "Read",   tool_input.file_path ".../skills/<name>/SKILL.md"
+ * - Codex:   tool_name "Bash",   tool_input.command containing ".../skills/<name>/SKILL.md" */
+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 [];
+}
+/** Largest decoded `--cmd-b64` command we run. */
+exports.MAX_GATED_COMMAND_BYTES = 16 * 1024;
+/** Canonical form (what the portal writes): base64url of the UTF-8 command, no
+ * padding. Only [A-Za-z0-9_-], so no shell on any platform expands or
+ * re-quotes it — a `$(…)` in the gated command can't run before the gate. */
+function encodeGatedCommand(command) {
+    return Buffer.from(command, "utf8").toString("base64url");
+}
+/** Strict decode: canonical base64url only, ≤16KB, valid UTF-8, no NUL. */
+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));
+}
+/** Split a CODIEDEV_HOOK_SHELL value ("pwsh -NoProfile -Command") into argv,
+ * honouring simple "double" or 'single' quotes. */
+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") {
+        // Same invocation Node uses for shell:true on Windows.
+        return { file: env.ComSpec || env.COMSPEC || "cmd.exe", args: ["/d", "/s", "/c", `"${line}"`], verbatim: true };
+    }
+    return { file: "/bin/sh", args: ["-c", line] };
+}
+/** The decoded `--cmd-b64` command line, run by the platform shell
+ * (/bin/sh -c on POSIX, cmd.exe /d /s /c on Windows, or CODIEDEV_HOOK_SHELL). */
+function planShellCommand(line, options = {}) {
+    return shellFor(line, options.platform ?? process.platform, options.env ?? process.env);
+}
+/** `-- <argv…>`: exec'd directly, no shell. Legacy `sh -c '<cmd>'` (packs saved
+ * before --cmd-b64) runs as given, except on Windows without sh, where <cmd>
+ * goes to cmd.exe. */
+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 {
+                // keep looking
+            }
+        }
+    }
+    return false;
+}
+/** Returns the exit status to use. */
+function runHookGate(argv, stdin, env = process.env, options = {}) {
+    let args;
+    try {
+        args = parseGateArgs(argv);
+    }
+    catch (error) {
+        // A misconfigured gate must not block the agent; say why on stderr.
+        process.stderr.write(`codiedev hook-gate: ${error.message}\n`);
+        return 0;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(stdin);
+    }
+    catch {
+        return 0;
+    }
+    // Nothing is decoded or run unless one of the skills is in use.
+    if (!gateMatches(args.skills, payload))
+        return 0;
+    let plan;
+    if (args.cmdB64 !== undefined) {
+        let line;
+        try {
+            line = decodeGatedCommand(args.cmdB64);
+        }
+        catch (error) {
+            // Never block the agent on a malformed gate.
+            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 } : {}),
+    });
+    // A command that exits without reading its stdin (`exit 2`, `touch x`)
+    // closes the pipe before the payload is written; spawnSync then reports
+    // EPIPE next to the command's real exit status, which is the answer.
+    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.d.ts

@@ -0,0 +1,46 @@
+import { CodexHookTrustEntry } from "../codexHookTrust";
+import { AdapterResult, HarnessName, Runner } from "./harnesses";
+import { PackManifest } from "./manifest";
+import { Registry } from "./store";
+export interface InstallOptions {
+    manifests: PackManifest[];
+    harnesses?: HarnessName[];
+    dryRun?: boolean;
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    run?: Runner;
+    now?: () => number;
+}
+export interface PackInstallResult {
+    slug: string;
+    channel?: string;
+    version: number;
+    contentHash: string;
+    dir: string;
+    files: string[];
+    results: AdapterResult[];
+    harnesses: string[];
+}
+/** Where Codex unpacked this pack's hooks.json after `codex plugin add`. */
+export declare function codexPackHooksPath(codexDir: string, slug: string, version: number): string | null;
+/** Trust entries for every registry pack installed into Codex. */
+export declare function codexPackTrustEntries(registry: Registry, codexDir: string): Map<string, CodexHookTrustEntry[]>;
+export declare function installPacks(options: InstallOptions): PackInstallResult[];
+export interface UninstallOptions {
+    slugs: string[];
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    run?: Runner;
+}
+export interface PackUninstallResult {
+    slug: string;
+    results: AdapterResult[];
+}
+/** Remove packs that no longer apply (unassigned or archived): run each
+ * tool's uninstall, drop the plugin dir, the marketplace entry, the registry
+ * entry, its Codex trust entries and its shim hooks. Unknown slugs are a
+ * no-op. A tool failing to uninstall never keeps the pack registered — the
+ * pack is no longer authorized, so local state must stop advertising it. */
+export declare function uninstallPacks(options: UninstallOptions): PackUninstallResult[];
+export declare function formatUninstallLines(results: PackUninstallResult[]): string[];
+export declare function formatResultLines(results: PackInstallResult[]): string[];

package/dist/packs/install.js

@@ -0,0 +1,306 @@
+"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;
+// Orchestrates `codiedev pack install`: write the plugin dir + marketplace,
+// run every detected tool's adapter, record installed.json, then regenerate
+// the Codex pack trust block and the Codie hook shim from the registry.
+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,
+    }));
+}
+/** Where Codex unpacked this pack's hooks.json after `codex plugin add`. */
+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 {
+                // no hooks in this version dir
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return best?.file ?? null;
+}
+/** Trust entries for every registry pack installed into Codex. */
+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 {
+            // hooks/hooks.json sits at the root of the installed plugin bundle.
+            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 {
+            // unreadable hooks → not trusted
+        }
+    }
+    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 {
+            // no hooks for this pack
+        }
+    }
+    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);
+        // Same plugin with agent model levels removed, for Codex/Copilot/Cursor.
+        (0, store_1.writePluginDir)((0, paths_1.portableRoot)(root), manifest, { portable: true });
+        // Harnesses read the marketplace during install, so it must list this pack first.
+        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) });
+            }
+        }
+        // Tools not selected this run keep their previous state; selected ones
+        // reflect this run's outcome.
+        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;
+}
+/** Remove packs that no longer apply (unassigned or archived): run each
+ * tool's uninstall, drop the plugin dir, the marketplace entry, the registry
+ * entry, its Codex trust entries and its shim hooks. Unknown slugs are a
+ * no-op. A tool failing to uninstall never keeps the pack registered — the
+ * pack is no longer authorized, so local state must stop advertising it. */
+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));
+    // Regenerate even when Codex isn't on PATH any more: a stale trust entry
+    // for a removed pack must not survive in config.toml.
+    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;
+}