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

package/dist/packs/harnesses.js

@@ -0,0 +1,374 @@
+"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.ADAPTERS = exports.codieAdapter = exports.cursorAdapter = exports.CURSOR_MARKER = exports.codexAdapter = exports.copilotAdapter = exports.claudeAdapter = exports.HARNESSES = void 0;
+exports.defaultRunner = defaultRunner;
+exports.onPath = onPath;
+exports.copyCursorSkills = copyCursorSkills;
+exports.removeCursorSkills = removeCursorSkills;
+exports.cursorLocalPluginsDir = cursorLocalPluginsDir;
+exports.cursorPluginDir = cursorPluginDir;
+exports.installCursorPlugin = installCursorPlugin;
+exports.removeCursorPlugin = removeCursorPlugin;
+exports.parseHarnessList = parseHarnessList;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const harnessDirs_1 = require("../harnessDirs");
+const paths_1 = require("./paths");
+exports.HARNESSES = ["claude", "copilot", "codex", "cursor", "codie"];
+function defaultRunner(env) {
+    return (command, args, options = {}) => {
+        const result = (0, child_process_1.spawnSync)(command, args, {
+            encoding: "utf8",
+            env,
+            cwd: options.cwd,
+            timeout: 180_000,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return {
+            status: result.status,
+            stdout: result.stdout ?? "",
+            stderr: result.stderr ?? "",
+            ...(result.error ? { error: result.error.message } : {}),
+        };
+    };
+}
+function onPath(bin, env) {
+    const dirs = (env.PATH ?? "").split(path.delimiter).filter(Boolean);
+    const exts = process.platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
+    for (const dir of dirs) {
+        for (const ext of exts) {
+            const candidate = path.join(dir, bin + ext);
+            try {
+                const stat = fs.statSync(candidate);
+                if (stat.isFile()) {
+                    if (process.platform === "win32")
+                        return true;
+                    fs.accessSync(candidate, fs.constants.X_OK);
+                    return true;
+                }
+            }
+            catch {
+            }
+        }
+    }
+    return false;
+}
+function uninstallRef(slug) {
+    return `${slug}@${paths_1.MARKETPLACE_NAME}`;
+}
+function uninstallWith(ctx, bin, verb) {
+    const result = ctx.run(bin, ["plugin", verb, uninstallRef(ctx.slug)]);
+    if (result.status === 0)
+        return "uninstalled";
+    if (/not (found|installed)/i.test(`${result.stdout}\n${result.stderr}`))
+        return "already removed";
+    throw new Error(`\`${bin} plugin ${verb} ${uninstallRef(ctx.slug)}\` failed (${describe(result)})`);
+}
+function describe(result) {
+    if (result.error)
+        return result.error;
+    const text = (result.stderr || result.stdout || "").trim().split("\n").filter(Boolean).pop();
+    return text ? `exit ${result.status}: ${text.slice(0, 200)}` : `exit ${result.status}`;
+}
+function must(ctx, bin, args, options) {
+    const result = ctx.run(bin, args, options);
+    if (result.status !== 0)
+        throw new Error(`\`${bin} ${args.join(" ")}\` failed (${describe(result)})`);
+    return result;
+}
+function alreadyExists(result) {
+    return /already|exists/i.test(`${result.stdout}\n${result.stderr}`);
+}
+function wasInstalled(ctx, harness) {
+    return Boolean(ctx.previous?.harnesses?.includes(harness));
+}
+function contentChangedInPlace(ctx) {
+    const prev = ctx.previous;
+    return Boolean(prev && prev.version === ctx.manifest.version && prev.contentHash !== ctx.manifest.contentHash);
+}
+function pluginRef(ctx) {
+    return `${ctx.manifest.slug}@${paths_1.MARKETPLACE_NAME}`;
+}
+function claudeMarketplaceKnown(env, home) {
+    try {
+        const known = JSON.parse(fs.readFileSync(path.join((0, harnessDirs_1.claudeConfigDir)(env, home), "plugins", "known_marketplaces.json"), "utf8"));
+        return Boolean(known && typeof known === "object" && paths_1.MARKETPLACE_NAME in known);
+    }
+    catch {
+        return false;
+    }
+}
+function ensurePortableMarketplace(ctx, bin) {
+    const root = (0, paths_1.portableRoot)(ctx.root);
+    const stamp = path.join(root, `.registered-${bin}`);
+    if (!fs.existsSync(stamp))
+        ctx.run(bin, ["plugin", "marketplace", "remove", paths_1.MARKETPLACE_NAME]);
+    const added = ctx.run(bin, ["plugin", "marketplace", "add", root]);
+    if (added.status !== 0 && !alreadyExists(added)) {
+        throw new Error(`\`${bin} plugin marketplace add\` failed (${describe(added)})`);
+    }
+    fs.writeFileSync(stamp, `${root}\n`);
+}
+function marketplaceInstall(ctx, bin, harness, verbs, marketplaceKnown, portable = false) {
+    if (portable) {
+        ensurePortableMarketplace(ctx, bin);
+    }
+    else if (marketplaceKnown) {
+        ctx.run(bin, ["plugin", "marketplace", "update", paths_1.MARKETPLACE_NAME]);
+    }
+    else {
+        const added = ctx.run(bin, ["plugin", "marketplace", "add", ctx.root]);
+        if (added.status !== 0 && !alreadyExists(added)) {
+            throw new Error(`\`${bin} plugin marketplace add\` failed (${describe(added)})`);
+        }
+        if (added.status !== 0)
+            ctx.run(bin, ["plugin", "marketplace", "update", paths_1.MARKETPLACE_NAME]);
+    }
+    const ref = pluginRef(ctx);
+    if (wasInstalled(ctx, harness)) {
+        if (contentChangedInPlace(ctx)) {
+            ctx.run(bin, ["plugin", verbs.uninstall, ref]);
+            must(ctx, bin, ["plugin", verbs.install, ref]);
+            return "reinstalled";
+        }
+        const updated = ctx.run(bin, ["plugin", verbs.update, ref]);
+        if (updated.status === 0)
+            return "updated";
+    }
+    const installed = ctx.run(bin, ["plugin", verbs.install, ref]);
+    if (installed.status === 0)
+        return "installed";
+    if (alreadyExists(installed)) {
+        must(ctx, bin, ["plugin", verbs.update, ref]);
+        return "updated";
+    }
+    throw new Error(`\`${bin} plugin ${verbs.install} ${ref}\` failed (${describe(installed)})`);
+}
+exports.claudeAdapter = {
+    name: "claude",
+    detect: (ctx) => onPath("claude", ctx.env),
+    install: (ctx) => marketplaceInstall(ctx, "claude", "claude", { install: "install", update: "update", uninstall: "uninstall" }, claudeMarketplaceKnown(ctx.env, ctx.home)),
+    plan: (ctx) => `claude plugin marketplace add ${ctx.root}; claude plugin install ${pluginRef(ctx)}`,
+    uninstall: (ctx) => uninstallWith(ctx, "claude", "uninstall"),
+};
+exports.copilotAdapter = {
+    name: "copilot",
+    detect: (ctx) => onPath("copilot", ctx.env),
+    install: (ctx) => marketplaceInstall(ctx, "copilot", "copilot", { install: "install", update: "update", uninstall: "uninstall" }, false, true),
+    plan: (ctx) => `copilot plugin marketplace add ${(0, paths_1.portableRoot)(ctx.root)}; copilot plugin install ${pluginRef(ctx)}`,
+    uninstall: (ctx) => uninstallWith(ctx, "copilot", "uninstall"),
+};
+exports.codexAdapter = {
+    name: "codex",
+    detect: (ctx) => onPath("codex", ctx.env),
+    install: (ctx) => {
+        ensurePortableMarketplace(ctx, "codex");
+        const ref = pluginRef(ctx);
+        const reinstall = wasInstalled(ctx, "codex");
+        if (reinstall)
+            ctx.run("codex", ["plugin", "remove", ref]);
+        must(ctx, "codex", ["plugin", "add", ref]);
+        return reinstall ? "reinstalled" : "installed";
+    },
+    plan: (ctx) => `codex plugin marketplace add ${(0, paths_1.portableRoot)(ctx.root)}; codex plugin add ${pluginRef(ctx)}; trust pack hooks in config.toml`,
+    uninstall: (ctx) => uninstallWith(ctx, "codex", "remove"),
+};
+exports.CURSOR_MARKER = ".codiedev-pack";
+function cursorSkillsDir(home) {
+    return path.join(home, ".cursor", "skills");
+}
+function copyCursorSkills(home, manifest, pluginDirPath) {
+    const base = cursorSkillsDir(home);
+    fs.mkdirSync(base, { recursive: true });
+    const notes = [];
+    const wanted = new Set(manifest.skills.map((s) => s.name));
+    for (const entry of fs.readdirSync(base)) {
+        const marker = path.join(base, entry, exports.CURSOR_MARKER);
+        try {
+            if (fs.readFileSync(marker, "utf8").trim() === manifest.slug && !wanted.has(entry)) {
+                fs.rmSync(path.join(base, entry), { recursive: true, force: true });
+            }
+        }
+        catch {
+        }
+    }
+    for (const skill of manifest.skills) {
+        const dest = path.join(base, skill.name);
+        if (fs.existsSync(dest)) {
+            let owner = "";
+            try {
+                owner = fs.readFileSync(path.join(dest, exports.CURSOR_MARKER), "utf8").trim();
+            }
+            catch {
+                owner = "";
+            }
+            if (owner !== manifest.slug) {
+                notes.push(`kept existing ~/.cursor/skills/${skill.name}`);
+                continue;
+            }
+            fs.rmSync(dest, { recursive: true, force: true });
+        }
+        fs.mkdirSync(dest, { recursive: true });
+        fs.copyFileSync(path.join(pluginDirPath, "skills", skill.name, "SKILL.md"), path.join(dest, "SKILL.md"));
+        fs.writeFileSync(path.join(dest, exports.CURSOR_MARKER), `${manifest.slug}\n`);
+    }
+    return notes;
+}
+function removeCursorSkills(home, slug) {
+    const base = cursorSkillsDir(home);
+    let removed = 0;
+    let entries = [];
+    try {
+        entries = fs.readdirSync(base);
+    }
+    catch {
+        return 0;
+    }
+    for (const entry of entries) {
+        try {
+            if (fs.readFileSync(path.join(base, entry, exports.CURSOR_MARKER), "utf8").trim() === slug) {
+                fs.rmSync(path.join(base, entry), { recursive: true, force: true });
+                removed += 1;
+            }
+        }
+        catch {
+        }
+    }
+    return removed;
+}
+function cursorLocalPluginsDir(home) {
+    return path.join(home, ".cursor", "plugins", "local");
+}
+function cursorPluginDir(home, slug) {
+    return path.join(cursorLocalPluginsDir(home), `codiedev-${slug}`);
+}
+function markerOwner(dir) {
+    try {
+        return fs.readFileSync(path.join(dir, exports.CURSOR_MARKER), "utf8").trim();
+    }
+    catch {
+        return null;
+    }
+}
+function copyTreeNoSymlinks(source, dest, depth = 0) {
+    if (depth > 32)
+        throw new Error(`plugin tree too deep at ${source}`);
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(source)) {
+        const from = path.join(source, entry);
+        const to = path.join(dest, entry);
+        const stat = fs.statSync(from);
+        if (stat.isDirectory())
+            copyTreeNoSymlinks(from, to, depth + 1);
+        else if (stat.isFile())
+            fs.writeFileSync(to, fs.readFileSync(from));
+    }
+}
+function installCursorPlugin(home, slug, sourceDir) {
+    const parent = cursorLocalPluginsDir(home);
+    const target = cursorPluginDir(home, slug);
+    if (fs.existsSync(target) && markerOwner(target) !== slug) {
+        throw new Error(`${target} exists and wasn't written by Codiedev; leaving it alone`);
+    }
+    fs.mkdirSync(parent, { recursive: true });
+    const stamp = `${process.pid}-${Date.now()}`;
+    const tmp = path.join(parent, `.codiedev-${slug}.tmp-${stamp}`);
+    const old = path.join(parent, `.codiedev-${slug}.old-${stamp}`);
+    try {
+        copyTreeNoSymlinks(sourceDir, tmp);
+        fs.writeFileSync(path.join(tmp, exports.CURSOR_MARKER), `${slug}\n`);
+        if (fs.existsSync(target))
+            fs.renameSync(target, old);
+        fs.renameSync(tmp, target);
+    }
+    catch (error) {
+        fs.rmSync(tmp, { recursive: true, force: true });
+        if (!fs.existsSync(target) && fs.existsSync(old))
+            fs.renameSync(old, target);
+        throw error;
+    }
+    fs.rmSync(old, { recursive: true, force: true });
+    return target;
+}
+function removeCursorPlugin(home, slug) {
+    const target = cursorPluginDir(home, slug);
+    if (markerOwner(target) !== slug)
+        return false;
+    fs.rmSync(target, { recursive: true, force: true });
+    return true;
+}
+exports.cursorAdapter = {
+    name: "cursor",
+    detect: (ctx) => onPath("cursor-agent", ctx.env) || fs.existsSync(path.join(ctx.home, ".cursor")),
+    install: (ctx) => {
+        try {
+            installCursorPlugin(ctx.home, ctx.manifest.slug, ctx.portablePluginDir);
+        }
+        catch (error) {
+            const notes = copyCursorSkills(ctx.home, ctx.manifest, ctx.portablePluginDir);
+            const reason = error instanceof Error ? error.message : String(error);
+            return [`skills only (couldn't write ~/.cursor/plugins/local: ${reason})`, ...notes].join("; ");
+        }
+        const migrated = removeCursorSkills(ctx.home, ctx.manifest.slug);
+        return migrated ? `installed (removed ${migrated} old ~/.cursor/skills cop${migrated === 1 ? "y" : "ies"})` : "installed";
+    },
+    plan: (ctx) => `copy plugin to ${cursorPluginDir(ctx.home, ctx.manifest.slug)}`,
+    uninstall: (ctx) => {
+        const plugin = removeCursorPlugin(ctx.home, ctx.slug);
+        const skills = removeCursorSkills(ctx.home, ctx.slug);
+        if (!plugin && !skills)
+            return "already removed";
+        return skills ? `uninstalled (${skills} copied skill${skills === 1 ? "" : "s"} removed)` : "uninstalled";
+    },
+};
+exports.codieAdapter = {
+    name: "codie",
+    detect: () => true,
+    install: () => "loads on next `codie` launch",
+    plan: () => "inject skills/agents/hook shim at next codie launch",
+    uninstall: () => "removed from next `codie` launch",
+};
+exports.ADAPTERS = [exports.claudeAdapter, exports.copilotAdapter, exports.codexAdapter, exports.cursorAdapter, exports.codieAdapter];
+function parseHarnessList(value) {
+    if (value === undefined)
+        return undefined;
+    const names = value.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+    const unknown = names.filter((n) => !exports.HARNESSES.includes(n));
+    if (unknown.length)
+        throw new Error(`Unknown harness: ${unknown.join(", ")} (valid: ${exports.HARNESSES.join(", ")})`);
+    return [...new Set(names)];
+}

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);
+}