@ccoalm/ccl-skills 0.1.0

package/dist/claude-adapter.d.ts

@@ -0,0 +1,9 @@
+import type { Options, Result } from "./types.js";
+export interface ClaudeContext {
+    home?: string;
+    assets?: string;
+    env?: NodeJS.ProcessEnv;
+    isInterrupted?: () => boolean;
+    removeRoot?: (path: string) => void;
+}
+export declare function runClaude(commandName: string, options?: Options, context?: ClaudeContext): Result;

package/dist/claude-adapter.js

@@ -0,0 +1,240 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, lstatSync, mkdirSync, renameSync, rmSync, } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { atomicJson, canonicalAlias, copyRegularTree, verifyTree } from "./fs-safe.js";
+import { manifestFor, readManifest, readRelease } from "./manifest.js";
+import { compare } from "./version.js";
+const MARKET = "ccl-skills-npm", REF = `ccl-skills@${MARKET}`;
+function paths(context) {
+    const rawHome = context.home ?? (context.env ? context.env.HOME : process.env.HOME);
+    if (!rawHome || !isAbsolute(rawHome))
+        throw new Error("HOME is not set; refusing to guess a managed root");
+    const home = resolve(rawHome), claudeHome = join(home, ".claude"), root = join(claudeHome, MARKET), assets = resolve(context.assets || join(dirname(fileURLToPath(import.meta.url)), "assets"));
+    return { home, claudeHome, root, manifest: join(root, "install-manifest.json"), assets, release: join(assets, "release.json") };
+}
+class InterruptedOperation extends Error {
+}
+function throwIfInterrupted(context) {
+    if (context.isInterrupted?.())
+        throw new InterruptedOperation("Claude operation interrupted");
+}
+const samePath = (left, right) => canonicalAlias(resolve(left)) === canonicalAlias(resolve(right));
+function assertExclusiveRoot(base, root, createBase = false) {
+    if (resolve(root) !== join(resolve(base), MARKET))
+        throw new Error("managed root is not canonical");
+    if (createBase)
+        mkdirSync(base, { recursive: true });
+    let cursor = resolve(base);
+    for (const component of [cursor, root, join(root, "snapshots")]) {
+        if (!existsSync(component))
+            continue;
+        const stat = lstatSync(component);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw new Error(`unsafe managed component: ${component}`);
+    }
+}
+function command(args, context, allowFailure = false) {
+    const result = spawnSync("claude", args, {
+        encoding: "utf8",
+        env: context.env || process.env,
+    });
+    if (result.error && !allowFailure)
+        throw result.error;
+    if (result.status !== 0 && !allowFailure)
+        throw new Error(`claude ${args.slice(0, 3).join(" ")} failed (${result.status}): ${(result.stderr || result.stdout).trim()}`);
+    return result;
+}
+function state(context) {
+    const version = command(["--version"], context, true);
+    if (version.status !== 0)
+        return { host: false, marketplace: null, plugin: false, legacy: false };
+    const marketsRaw = command(["plugin", "marketplace", "list", "--json"], context), pluginsRaw = command(["plugin", "list", "--json"], context);
+    let markets, plugins;
+    try {
+        markets = JSON.parse(marketsRaw.stdout);
+        plugins = JSON.parse(pluginsRaw.stdout);
+    }
+    catch {
+        throw new Error("Claude plugin state is not valid JSON");
+    }
+    if (!Array.isArray(markets) || !Array.isArray(plugins))
+        throw new Error("Claude plugin state has an invalid shape");
+    const targetMarkets = markets.filter((entry) => entry && typeof entry === "object" && entry.name === MARKET);
+    if (targetMarkets.length > 1)
+        throw new Error("duplicate Claude npm marketplace");
+    const marketplace = targetMarkets.length
+        ? String(targetMarkets[0].installLocation || targetMarkets[0].path || "")
+        : null;
+    const ids = plugins.map((entry) => entry && typeof entry === "object" ? entry.id : null);
+    return {
+        host: true,
+        marketplace,
+        plugin: ids.includes(REF),
+        legacy: ids.includes("ccl-skills@ccl-skills") || markets.some((entry) => entry && typeof entry === "object" && entry.name === "ccl-skills"),
+    };
+}
+function prepare(context, old) {
+    const p = paths(context), release = readRelease(p.release), rel = join("snapshots", release.snapshotHash), snapshot = join(p.root, rel), snapshots = join(p.root, "snapshots");
+    assertExclusiveRoot(p.claudeHome, p.root, true);
+    mkdirSync(snapshots, { recursive: true });
+    assertExclusiveRoot(p.claudeHome, p.root);
+    if (!existsSync(snapshot)) {
+        const staging = join(snapshots, `.staging-${release.snapshotHash}-${process.pid}`);
+        rmSync(staging, { recursive: true, force: true });
+        copyRegularTree(join(p.assets, "marketplace"), join(staging, "marketplace"));
+        const errors = verifyTree(staging, release.files);
+        if (errors.length) {
+            rmSync(staging, { recursive: true, force: true });
+            throw new Error(`staged Claude snapshot failed verification: ${errors.join("; ")}`);
+        }
+        mkdirSync(dirname(snapshot), { recursive: true });
+        renameSync(staging, snapshot);
+    }
+    else {
+        const errors = verifyTree(snapshot, release.files);
+        if (errors.length)
+            throw new Error(`Claude snapshot drifted: ${errors.join("; ")}`);
+    }
+    return { p, release, rel, snapshot, manifest: manifestFor(release, rel, old?.active || null) };
+}
+function removeRegistration(context) {
+    const current = state(context);
+    if (current.plugin)
+        command(["plugin", "uninstall", REF, "--scope", "user"], context);
+    if (current.marketplace)
+        command(["plugin", "marketplace", "remove", MARKET, "--scope", "user"], context);
+}
+function installRegistration(marketplace, context) {
+    command(["plugin", "marketplace", "add", marketplace, "--scope", "user"], context);
+    command(["plugin", "install", REF, "--scope", "user"], context);
+    const current = state(context);
+    if (!current.plugin || !samePath(current.marketplace || "", marketplace))
+        throw new Error("Claude did not expose the exact npm marketplace candidate");
+}
+function doctor(context) {
+    const p = paths(context);
+    assertExclusiveRoot(p.claudeHome, p.root);
+    const current = state(context);
+    if (!current.host)
+        return { code: 4, status: "host-missing", message: "Claude CLI is not installed" };
+    if (current.legacy)
+        return { code: 3, status: "double-install", message: "Git marketplace and npm marketplace are both present; keep exactly one" };
+    const manifest = readManifest(p.manifest);
+    if (!manifest) {
+        if (current.plugin || current.marketplace)
+            return { code: 3, status: "unowned-registration", message: "Claude npm registration exists without an owned manifest" };
+        return { code: 3, status: "absent", message: "ccl-skills is not installed for Claude" };
+    }
+    const snapshot = join(p.root, manifest.active.path), errors = verifyTree(snapshot, manifest.active.ownedFiles), expected = join(snapshot, "marketplace");
+    if (errors.length)
+        return { code: 3, status: "owned-drift", message: "Claude owned snapshot drifted", details: { errors } };
+    if (!current.plugin || !samePath(current.marketplace || "", expected))
+        return { code: 3, status: "public-state-mismatch", message: "Claude public state does not match the owned manifest" };
+    return { code: 0, status: "healthy", message: `Claude uses @ccoalm/ccl-skills ${manifest.active.version}` };
+}
+function installOrUpdate(commandName, options, context) {
+    const p = paths(context);
+    assertExclusiveRoot(p.claudeHome, p.root, true);
+    const current = state(context);
+    if (!current.host)
+        return { code: 4, status: "host-missing", message: "Claude CLI is not installed" };
+    if (current.legacy)
+        return { code: 3, status: "double-install", message: "Remove the Git marketplace install or choose it instead of npm" };
+    const old = readManifest(p.manifest), release = readRelease(p.release);
+    if (!old && (current.plugin || current.marketplace))
+        return { code: 3, status: "unowned-registration", message: "refusing to replace a Claude npm registration without an owned manifest" };
+    if (commandName === "update" && !old)
+        return { code: 3, status: "not-installed", message: "update requires an existing owned Claude installation" };
+    if (old) {
+        const snapshot = join(p.root, old.active.path), errors = verifyTree(snapshot, old.active.ownedFiles), expectedMarket = join(snapshot, "marketplace");
+        if (errors.length)
+            return { code: 3, status: "owned-drift", message: "Claude owned snapshot drifted", details: { errors } };
+        if (!current.plugin || !samePath(current.marketplace || "", expectedMarket))
+            return { code: 3, status: "public-state-mismatch", message: "refusing to replace Claude state that does not match the owned manifest" };
+        const comparison = compare(release.version, old.active.version);
+        if (comparison === 0)
+            return doctor(context);
+        if (commandName === "install")
+            return { code: 3, status: "use-update", message: "an owned Claude version exists; use update" };
+        if (comparison < 0 && !options.allowDowngrade)
+            return { code: 3, status: "downgrade-refused", message: "newer Claude assets are installed" };
+    }
+    if (commandName === "update" && !options.yes)
+        return { code: 0, status: "dry-run", message: "Claude update preview", plan: ["stage immutable marketplace", "replace user registration", "verify exact local source"] };
+    const candidate = prepare(context, old), candidateMarket = join(candidate.snapshot, "marketplace"), oldMarket = old ? join(p.root, old.active.path, "marketplace") : null;
+    if (context.isInterrupted?.())
+        return { code: 130, status: "interrupted", message: "Claude operation interrupted before public mutation", interrupted: true };
+    try {
+        if (current.plugin || current.marketplace)
+            removeRegistration(context);
+        throwIfInterrupted(context);
+        installRegistration(candidateMarket, context);
+        throwIfInterrupted(context);
+        atomicJson(p.manifest, candidate.manifest);
+        if (old?.previous) {
+            try {
+                rmSync(join(p.root, old.previous.path), { recursive: true, force: true });
+            }
+            catch (error) {
+                return { code: 5, status: "updated-stale-cleanup", message: `Claude update committed but superseded snapshot cleanup failed: ${String(error)}` };
+            }
+        }
+        return { code: 0, status: old ? "updated" : "installed", message: `Claude now uses @ccoalm/ccl-skills ${candidate.release.version}` };
+    }
+    catch (error) {
+        const interrupted = error instanceof InterruptedOperation;
+        try {
+            removeRegistration(context);
+            if (oldMarket)
+                installRegistration(oldMarket, context);
+            return { code: interrupted ? 130 : 1, status: interrupted && !oldMarket ? "interrupted" : "rolled-back", message: String(error), ...(interrupted ? { interrupted: true } : {}) };
+        }
+        catch (rollbackError) {
+            return { code: interrupted ? 130 : 5, status: "partial", message: `${String(error)}; rollback failed: ${String(rollbackError)}`, ...(interrupted ? { interrupted: true } : {}) };
+        }
+    }
+}
+function uninstall(options, context) {
+    const p = paths(context);
+    assertExclusiveRoot(p.claudeHome, p.root);
+    const manifest = readManifest(p.manifest), current = state(context);
+    if (!manifest && !current.plugin && !current.marketplace)
+        return { code: 0, status: "absent", message: "Claude npm install is already absent" };
+    if (!manifest)
+        return { code: 3, status: "unowned-registration", message: "refusing to remove an unowned Claude registration" };
+    if (!current.host)
+        return { code: 4, status: "host-missing", message: "Claude CLI is not installed; refusing to drop ownership evidence while registration cannot be verified" };
+    if (!options.yes)
+        return { code: 0, status: "dry-run", message: "Claude uninstall preview", plan: ["remove npm plugin", "remove npm marketplace", "delete exclusive owned snapshots"] };
+    if (context.isInterrupted?.())
+        return { code: 130, status: "interrupted", message: "Claude uninstall interrupted before registration mutation", interrupted: true };
+    removeRegistration(context);
+    const after = state(context);
+    if (after.plugin || after.marketplace)
+        return { code: 5, status: "partial", message: "Claude registration remains after uninstall" };
+    try {
+        if (context.removeRoot)
+            context.removeRoot(p.root);
+        else
+            rmSync(p.root, { recursive: true, force: true });
+    }
+    catch (error) {
+        return { code: 5, status: "partial", message: `Claude registration removed but owned snapshot cleanup failed: ${String(error)}` };
+    }
+    return { code: 0, status: "uninstalled", message: "Claude npm registration and exclusive snapshots removed" };
+}
+export function runClaude(commandName, options = {}, context = {}) {
+    try {
+        if (commandName === "doctor")
+            return doctor(context);
+        if (commandName === "install" || commandName === "update")
+            return installOrUpdate(commandName, options, context);
+        if (commandName === "uninstall")
+            return uninstall(options, context);
+        return { code: 2, status: "usage", message: "unknown Claude command" };
+    }
+    catch (error) {
+        return { code: 3, status: "safety-refusal", message: error instanceof Error ? error.message : String(error) };
+    }
+}

package/dist/cli-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli-worker.js

@@ -0,0 +1,32 @@
+import { isMainThread, parentPort, workerData } from "node:worker_threads";
+import { runUnified } from "./unified.js";
+function valid(x) {
+    if (!x || typeof x !== "object")
+        return false;
+    const r = x;
+    return (r.protocol === 1 &&
+        ["install", "update", "doctor", "uninstall"].includes(r.command) &&
+        r.options !== null &&
+        typeof r.options === "object" &&
+        r.abortBuffer instanceof SharedArrayBuffer &&
+        r.abortBuffer.byteLength === Int32Array.BYTES_PER_ELEMENT);
+}
+if (!isMainThread) {
+    let result;
+    try {
+        if (!valid(workerData))
+            throw Error("invalid worker protocol");
+        const abort = new Int32Array(workerData.abortBuffer);
+        result = runUnified(workerData.command, workerData.options, {
+            isInterrupted: () => Atomics.load(abort, 0) === 1,
+        });
+    }
+    catch {
+        result = {
+            code: 5,
+            status: "worker-error",
+            message: "worker failed with unknown finality",
+        };
+    }
+    parentPort.postMessage(result);
+}

package/dist/cli.d.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { Worker } from "node:worker_threads";
+import type { Options, Result } from "./types.js";
+type Parsed = {
+    direct?: {
+        code: number;
+        stream: "stdout" | "stderr";
+        text: string;
+    };
+    command?: string;
+    options?: Options;
+    json?: boolean;
+};
+export declare function parseArgs(args: string[]): Parsed;
+export type SupervisorDeps = {
+    workerFactory?: (data: unknown) => Pick<Worker, "once" | "on">;
+    onSignal?: (fn: () => void) => () => void;
+};
+export declare function supervise(command: string, options: Options, deps?: SupervisorDeps): Promise<Result>;
+export declare function main(args: string[]): Promise<number>;
+export declare function isDirectEntrypoint(importMetaUrl: string, argv1: string | undefined): boolean;
+export {};

package/dist/cli.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+import { readFileSync, realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
+import { spawnSync } from "node:child_process";
+const pkg = JSON.parse(readFileSync(fileURLToPath(new URL("../package.json", import.meta.url)), "utf8"));
+const HELP = `ccl-skills — npm snapshot installer for Claude Code, Codex, and OpenCode\n\nUsage:\n  ccl-skills install [--host claude|codex|opencode] [--json]\n  ccl-skills update [--host claude|codex|opencode] [--yes] [--allow-downgrade] [--json]\n  ccl-skills doctor [--host claude|codex|opencode] [--json]\n  ccl-skills uninstall [--host claude|codex|opencode] [--yes] [--json]\n\nWithout --host, every installed or package-owned host is selected.\nUpdate and uninstall are dry-run unless --yes is supplied.\nBy default update --yes upgrades the global npm package to @latest before refreshing assets.\nSet CCL_SKILLS_SKIP_SELF_UPDATE=1 for an assets-only refresh; --allow-downgrade always uses the invoked package without installing @latest first.`;
+export function parseArgs(args) {
+    if (!args.length ||
+        args.includes("--help") ||
+        args.includes("-h") ||
+        args[0] === "help")
+        return { direct: { code: 0, stream: "stdout", text: HELP } };
+    if (args.includes("--version"))
+        return { direct: { code: 0, stream: "stdout", text: pkg.version } };
+    const command = args[0], flags = args.slice(1);
+    let host;
+    const normalizedFlags = [];
+    for (let index = 0; index < flags.length; index++) {
+        const flag = flags[index];
+        if (flag === "--host") {
+            const value = flags[++index];
+            if (!["claude", "codex", "opencode"].includes(value || ""))
+                return {
+                    direct: {
+                        code: 2,
+                        stream: "stderr",
+                        text: "--host requires claude, codex, or opencode.",
+                    },
+                };
+            host = value;
+        }
+        else
+            normalizedFlags.push(flag);
+    }
+    const allowed = new Set(["--yes", "-y", "--json", "--allow-downgrade"]);
+    if (!["install", "update", "doctor", "uninstall"].includes(command) ||
+        normalizedFlags.some((x) => !allowed.has(x)))
+        return {
+            direct: {
+                code: 2,
+                stream: "stderr",
+                text: "Invalid command or option. Run --help.",
+            },
+        };
+    const yes = normalizedFlags.includes("--yes") || normalizedFlags.includes("-y"), allowDowngrade = normalizedFlags.includes("--allow-downgrade");
+    if (allowDowngrade && (command !== "update" || !yes))
+        return {
+            direct: {
+                code: 2,
+                stream: "stderr",
+                text: "--allow-downgrade is valid only with update --yes.",
+            },
+        };
+    if (command === "install" && yes)
+        return {
+            direct: {
+                code: 2,
+                stream: "stderr",
+                text: "install does not accept --yes; it executes after safety checks.",
+            },
+        };
+    return {
+        command,
+        options: { yes, allowDowngrade, host },
+        json: normalizedFlags.includes("--json"),
+    };
+}
+const validResult = (x) => !!x &&
+    typeof x === "object" &&
+    [0, 1, 2, 3, 4, 5, 130].includes(x.code) &&
+    typeof x.status === "string" &&
+    typeof x.message === "string";
+export async function supervise(command, options, deps = {}) {
+    const abortBuffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT), abort = new Int32Array(abortBuffer);
+    let signalled = false, settled = false, messages = 0;
+    const worker = deps.workerFactory?.({ protocol: 1, command, options, abortBuffer }) ||
+        new Worker(new URL("./cli-worker.js", import.meta.url), {
+            workerData: { protocol: 1, command, options, abortBuffer },
+        });
+    const remove = (deps.onSignal ||
+        ((fn) => {
+            process.on("SIGINT", fn);
+            return () => process.removeListener("SIGINT", fn);
+        }))(() => {
+        signalled = true;
+        Atomics.store(abort, 0, 1);
+    });
+    return await new Promise((resolve) => {
+        const finish = (r) => {
+            if (settled)
+                return;
+            settled = true;
+            remove();
+            resolve(signalled && r.code !== 5 ? { ...r, code: 130, interrupted: true } : r);
+        };
+        worker.on("message", (x) => {
+            messages++;
+            if (messages > 1 || !validResult(x))
+                finish({
+                    code: 5,
+                    status: "worker-error",
+                    message: "worker protocol returned an invalid result",
+                });
+            else
+                queueMicrotask(() => {
+                    if (messages === 1)
+                        finish(x);
+                });
+        });
+        worker.once("error", () => finish({
+            code: 5,
+            status: "worker-error",
+            message: "worker failed with unknown finality",
+        }));
+        worker.once("exit", (code) => {
+            if (!settled && code !== 0)
+                finish({
+                    code: 5,
+                    status: "worker-error",
+                    message: "worker exited without a result; finality is unknown",
+                });
+            else if (!settled)
+                queueMicrotask(() => {
+                    if (!settled)
+                        finish({
+                            code: 5,
+                            status: "worker-error",
+                            message: "worker exited without a result; finality is unknown",
+                        });
+                });
+        });
+    });
+}
+function write(stream, text) {
+    try {
+        stream.write(`${text}\n`);
+    }
+    catch (e) {
+        if (!["EPIPE", "ERR_STREAM_DESTROYED"].includes(e.code || ""))
+            throw e;
+    }
+}
+function selfUpdate(options) {
+    const npm = spawnSync("npm", ["install", "--global", "@ccoalm/ccl-skills@latest", "--ignore-scripts"], {
+        encoding: "utf8",
+        env: process.env,
+    });
+    if (npm.error || npm.status !== 0)
+        return { code: 5, status: "package-update-failed", message: `npm global update failed (${npm.status ?? "spawn"}); host assets were not refreshed` };
+    const args = ["update", ...(options.host ? ["--host", options.host] : []), "--yes", ...(options.allowDowngrade ? ["--allow-downgrade"] : []), "--json"], fresh = spawnSync("ccl-skills", args, {
+        encoding: "utf8",
+        env: { ...process.env, CCL_SKILLS_SKIP_SELF_UPDATE: "1" },
+    });
+    if (fresh.error || fresh.status === null)
+        return { code: 5, status: "package-updated-assets-unknown", message: "npm package updated, but the fresh ccl-skills CLI could not be started" };
+    try {
+        const result = JSON.parse(fresh.stdout);
+        if (!validResult(result))
+            throw new Error("invalid result");
+        return result.code === 0 ? result : { ...result, details: { ...result.details, globalPackageUpdated: true } };
+    }
+    catch {
+        return { code: 5, status: "package-updated-assets-unknown", message: "npm package updated, but the fresh CLI returned an invalid result" };
+    }
+}
+export async function main(args) {
+    const parsed = parseArgs(args);
+    if (parsed.direct) {
+        write(parsed.direct.stream === "stdout" ? process.stdout : process.stderr, parsed.direct.text);
+        return parsed.direct.code;
+    }
+    const shouldSelfUpdate = parsed.command === "update" && parsed.options.yes && !parsed.options.allowDowngrade && process.env.CCL_SKILLS_SKIP_SELF_UPDATE !== "1";
+    let result;
+    if (shouldSelfUpdate) {
+        const preflight = await supervise("update", { ...parsed.options, yes: false });
+        result = preflight.code === 0 ? selfUpdate(parsed.options) : preflight;
+    }
+    else {
+        result = await supervise(parsed.command, parsed.options);
+    }
+    if (parsed.command === "update" && !parsed.options.yes && process.env.CCL_SKILLS_SKIP_SELF_UPDATE !== "1" && result.code === 0)
+        result = { ...result, plan: ["upgrade the global npm package @ccoalm/ccl-skills to @latest", ...(result.plan || [])] };
+    write(process.stdout, parsed.json
+        ? JSON.stringify(result)
+        : `${result.status}: ${result.message}${result.plan ? `\n${result.plan.map((x) => `- ${x}`).join("\n")}` : ""}`);
+    return result.code;
+}
+export function isDirectEntrypoint(importMetaUrl, argv1) {
+    if (!argv1)
+        return false;
+    try {
+        return realpathSync(fileURLToPath(importMetaUrl)) === realpathSync(argv1);
+    }
+    catch {
+        return false;
+    }
+}
+process.stdout.on("error", (e) => {
+    if (e.code === "EPIPE")
+        process.exitCode = 0;
+    else
+        throw e;
+});
+process.stderr.on("error", (e) => {
+    if (e.code === "EPIPE")
+        process.exitCode = 0;
+    else
+        throw e;
+});
+if (isDirectEntrypoint(import.meta.url, process.argv[1]))
+    main(process.argv.slice(2)).then((code) => {
+        process.exitCode = code;
+    });

package/dist/codex-host.d.ts

@@ -0,0 +1,30 @@
+export interface HostState {
+    status: "known" | "unknown";
+    marketplace: boolean;
+    marketplaceSource: string | null;
+    plugin: boolean;
+    legacy: boolean;
+    marketplaceOutput: string;
+    pluginOutput: string;
+}
+export declare function checkHost(codexHome?: string): {
+    ok: false;
+    kind: string;
+    message: string;
+    version?: undefined;
+} | {
+    ok: true;
+    version: string;
+    kind?: undefined;
+    message?: undefined;
+};
+export declare function parsePluginList(text: string, marketplaceSource: string | null): {
+    ok: boolean;
+    plugin: boolean;
+    legacy: boolean;
+};
+export declare function publicState(codexHome: string): HostState;
+export declare const marketplaceAdd: (path: string, codexHome?: string) => import("child_process").SpawnSyncReturns<string | NonSharedBuffer>;
+export declare const marketplaceRemove: (codexHome?: string) => import("child_process").SpawnSyncReturns<string | NonSharedBuffer>;
+export declare const pluginAdd: (codexHome?: string) => import("child_process").SpawnSyncReturns<string | NonSharedBuffer>;
+export declare const pluginRemove: (codexHome?: string) => import("child_process").SpawnSyncReturns<string | NonSharedBuffer>;