codiedev 0.9.67 → 0.9.68

package/dist/packs/harnesses.js

@@ -0,0 +1,407 @@
+"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;
+// Per-tool adapters. Each registers the pack's plugin dir (via the shared
+// local marketplace) with one coding tool. Adapters only run for tools that
+// are detected, and one failing never stops the others.
+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 } : {}),
+        };
+    };
+}
+/** True when `bin` is an executable file on `env.PATH`. */
+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 {
+                // keep looking
+            }
+        }
+    }
+    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));
+}
+/** A same-version reinstall whose content changed: harness caches are keyed
+ * by version, so the old copy must be removed before installing again. */
+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;
+    }
+}
+/** Shared flow for tools that install Claude-format plugins from a local
+ * marketplace (Claude Code, Copilot CLI). */
+/** Codex/Copilot register the portable root. Older CLIs registered the main
+ * root under the same name, so repoint once (remove, then add) per tool. */
+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) {
+        // Directory marketplaces are re-read on update; best-effort.
+        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);
+        // Codex caches by version under plugins/cache/<mkt>/<p>/<version>; remove
+        // first so a reinstall always picks up the current content.
+        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");
+}
+/** Fallback: copy skills to ~/.cursor/skills/<name>/, never overwriting a
+ * skill dir Codiedev didn't write, and pruning ones this pack no longer has. */
+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 {
+            // not ours
+        }
+    }
+    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;
+}
+/** Remove every ~/.cursor/skills dir this pack's fallback copy wrote. */
+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 {
+            // not ours
+        }
+    }
+    return removed;
+}
+// Cursor loads every Claude-format plugin dir in ~/.cursor/plugins/local/<name>/
+// (skills, agents and hooks). Its `plugin marketplace add` only takes remote
+// https git, and symlinks pointing outside plugins/local are rejected, so the
+// pack is a real copy. A Cursor team admin can disable "user local plugin
+// imports", in which case Cursor ignores the dir.
+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;
+    }
+}
+/** Recursive copy that always writes real files/dirs: symlinks are followed
+ * (Cursor rejects links whose target is outside plugins/local). fs.cpSync's
+ * `dereference` doesn't apply below the top level, so walk it ourselves. */
+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); // follows links
+        if (stat.isDirectory())
+            copyTreeNoSymlinks(from, to, depth + 1);
+        else if (stat.isFile())
+            fs.writeFileSync(to, fs.readFileSync(from));
+    }
+}
+/** Copy the plugin dir into place via a sibling temp dir + rename. Refuses to
+ * replace a dir that doesn't carry our marker for this pack. */
+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;
+}
+/** Remove our copy (only when it carries our marker). */
+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) {
+            // Last resort: skills only, where Cursor also looks.
+            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("; ");
+        }
+        // Migrate: the plugin now carries the skills; drop old fallback copies.
+        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",
+    // `codie` ships in this package, so it is always available.
+    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.d.ts

@@ -0,0 +1,53 @@
+import { spawnSync } from "child_process";
+/** 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" */
+export declare function skillsFromPayload(payload: unknown): string[];
+export interface GateArgs {
+    skills: string[];
+    /** `-- <argv…>`: exec'd directly (legacy `sh -c '<cmd>'` included). */
+    command: string[];
+    /** `--cmd-b64 <base64url>`: a command line for the platform shell. */
+    cmdB64?: string;
+}
+/** Largest decoded `--cmd-b64` command we run. */
+export declare const MAX_GATED_COMMAND_BYTES: number;
+/** 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. */
+export declare function encodeGatedCommand(command: string): string;
+/** Strict decode: canonical base64url only, ≤16KB, valid UTF-8, no NUL. */
+export declare function decodeGatedCommand(value: string): string;
+export declare function parseGateArgs(argv: string[]): GateArgs;
+export declare function gateMatches(skills: string[], payload: unknown): boolean;
+export interface GatePlan {
+    file: string;
+    args: string[];
+    /** cmd.exe needs its /c line passed verbatim (Node would re-quote it). */
+    verbatim?: boolean;
+    note?: string;
+}
+export interface PlanOptions {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    /** Whether `sh` is runnable (only consulted for the legacy form on Windows). */
+    hasSh?: () => boolean;
+}
+/** Split a CODIEDEV_HOOK_SHELL value ("pwsh -NoProfile -Command") into argv,
+ * honouring simple "double" or 'single' quotes. */
+export declare function splitShellOverride(value: string): string[];
+/** 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). */
+export declare function planShellCommand(line: string, options?: PlanOptions): GatePlan;
+/** `-- <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. */
+export declare function planGateCommand(command: string[], options?: PlanOptions): GatePlan;
+/** Returns the exit status to use. */
+export declare function runHookGate(argv: string[], stdin: string, env?: NodeJS.ProcessEnv, options?: Omit<PlanOptions, "env"> & {
+    spawn?: typeof spawnSync;
+}): number;
+export declare function runHookGateCli(argv: string[]): void;