@amsterdamdatalabs/enact-extensions 0.1.42 → 0.1.48

package/dist/install.js

@@ -1,697 +0,0 @@
-import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { projectAgentsDir, writeCursorHooksFile } from "./internal/agents.js";
-import { homedir } from "node:os";
-import { defaultCodexHome, ensureMarketplace, isPluginEnabled, readCodexConfig, removePluginConfig, resolveCodexInstallHomes, setPluginEnabled, writeCodexConfig, } from "./internal/codex.js";
-import { manifestForPlatform } from "./create/index.js";
-import { DEFAULT_MCP_FILENAME, DEFAULT_PATHS, PROJECTION_COMPONENT_FIELDS } from "./internal/platform.js";
-import { checkComponentPaths, readManifestFile, validateClaudeManifest, validateCodexManifest, validateCursorManifest, } from "./validate/index.js";
-import { defaultClaudeHome, readEnabledPlugins, readKnownMarketplaces, registerLocalMarketplace, removeClaudeMarketplaceEntry, upsertClaudeMarketplaceEntry, } from "./internal/claude.js";
-import { defaultCursorHome } from "./internal/cursor.js";
-import { provisionMcp } from "./provision.js";
-function readJson(path, fallback) {
-    if (!existsSync(path))
-        return fallback;
-    return JSON.parse(readFileSync(path, "utf8"));
-}
-function writeJson(path, value) {
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-}
-function pathFieldsFromManifest(platform, manifest) {
-    const fields = PROJECTION_COMPONENT_FIELDS[platform];
-    const results = [];
-    for (const field of fields) {
-        const value = manifest[field];
-        if (typeof value === "string" && value.trim())
-            results.push(value);
-    }
-    if (platform === "cursor") {
-        const logo = manifest.logo;
-        if (typeof logo === "string" && logo.trim())
-            results.push(logo);
-    }
-    const iface = manifest.interface;
-    if (iface && typeof iface === "object" && !Array.isArray(iface)) {
-        for (const field of ["composerIcon", "logo"]) {
-            const value = iface[field];
-            if (typeof value === "string" && value.trim())
-                results.push(value);
-        }
-    }
-    return results;
-}
-/**
- * Component path candidates to COPY for a surface. Derived per-surface manifests
- * may OMIT default-path fields (claude/cursor auto-discover from default dirs),
- * so we cannot rely on the manifest alone to know what to copy. We therefore
- * union the manifest's declared paths with the canonical default paths for each
- * auto-discovered component — the on-disk-existence check downstream filters out
- * components the bundle doesn't actually ship.
- */
-function copyPathCandidates(platform, manifest) {
-    const candidates = [...pathFieldsFromManifest(platform, manifest)];
-    // Fall back to canonical defaults for auto-discovered components that the
-    // derived manifest may have stripped (claude/cursor). Only consider fields the
-    // platform actually projects; codex/enact project canonical TOML agents while
-    // claude/cursor transform them to Markdown.
-    const projected = new Set(PROJECTION_COMPONENT_FIELDS[platform]);
-    for (const field of ["skills", "agents", "hooks", "mcpServers"]) {
-        if (!projected.has(field))
-            continue;
-        if (typeof manifest[field] === "string" && manifest[field].trim())
-            continue;
-        const def = DEFAULT_PATHS[field];
-        if (def)
-            candidates.push(def);
-    }
-    return candidates;
-}
-function normalizedProjectionEntries(platform, manifest, platformDir) {
-    const entries = new Set([platformDir, "README.md"]);
-    for (const raw of copyPathCandidates(platform, manifest)) {
-        const cleaned = raw.replace(/^\.\//, "").replace(/\/+$/, "");
-        if (!cleaned || cleaned.startsWith("../"))
-            continue;
-        entries.add(cleaned);
-    }
-    for (const hooksValue of [manifest.hooks, DEFAULT_PATHS.hooks]) {
-        if (typeof hooksValue === "string" && hooksValue.trim()) {
-            const cleaned = hooksValue.replace(/^\.\//, "").replace(/\/+$/, "");
-            if (cleaned.endsWith("/hooks.json")) {
-                const parentDir = dirname(cleaned);
-                if (parentDir !== ".")
-                    entries.add(parentDir);
-            }
-        }
-    }
-    return [...entries];
-}
-function cleanRel(value) {
-    if (typeof value !== "string")
-        return null;
-    const cleaned = value.replace(/^\.\//, "").replace(/\/+$/, "");
-    return cleaned && !cleaned.startsWith("../") ? cleaned : null;
-}
-function projectBundle(sourceRoot, targetRoot, platform, manifest, platformDir) {
-    rmSync(targetRoot, { recursive: true, force: true });
-    mkdirSync(targetRoot, { recursive: true });
-    // Resolve the agents source dir even when the derived manifest omits the field
-    // (claude/cursor auto-discover agents/ from the default location).
-    const agentsEntry = cleanRel(manifest.agents) ?? cleanRel(DEFAULT_PATHS.agents);
-    // The on-disk hooks file we project from (default path; bundles use it).
-    const hooksFileRel = (cleanRel(manifest.hooks) ?? cleanRel(DEFAULT_PATHS.hooks)) ?? "hooks/hooks.json";
-    const hooksDirRel = hooksFileRel.endsWith("/hooks.json") ? dirname(hooksFileRel) : null;
-    for (const entry of normalizedProjectionEntries(platform, manifest, platformDir)) {
-        const sourcePath = resolve(sourceRoot, entry);
-        if (!existsSync(sourcePath))
-            continue;
-        // Agents are transformed per surface (canonical .toml → .md for claude/cursor),
-        // not copied verbatim. Everything else copies as-is.
-        if (entry === agentsEntry && statSync(sourcePath).isDirectory()) {
-            projectAgentsDir(sourcePath, join(targetRoot, entry), platform);
-            continue;
-        }
-        // Cursor uses a different hooks schema (flat camelCase). Skip the raw hooks
-        // dir copy here; the projected hooks.json is written below instead.
-        if (platform === "cursor" && hooksDirRel && entry === hooksDirRel) {
-            continue;
-        }
-        cpSync(sourcePath, join(targetRoot, entry), { recursive: true, force: true });
-    }
-    if (platform === "cursor") {
-        // Project the canonical hooks.json into Cursor's flat camelCase schema,
-        // preserving any non-hooks files alongside it (e.g. hook scripts).
-        const hooksSource = resolve(sourceRoot, hooksFileRel);
-        if (existsSync(hooksSource) && hooksDirRel) {
-            const targetHooksDir = join(targetRoot, hooksDirRel);
-            const sourceHooksDir = resolve(sourceRoot, hooksDirRel);
-            // Copy sibling files (scripts) verbatim, then overwrite the hooks.json.
-            if (existsSync(sourceHooksDir) && statSync(sourceHooksDir).isDirectory()) {
-                for (const f of readdirSync(sourceHooksDir, { withFileTypes: true })) {
-                    if (f.name === "hooks.json")
-                        continue;
-                    cpSync(join(sourceHooksDir, f.name), join(targetHooksDir, f.name), {
-                        recursive: true,
-                        force: true,
-                    });
-                }
-            }
-            writeCursorHooksFile(hooksSource, join(targetRoot, hooksFileRel));
-        }
-        // Cursor convention: the MCP config file is `mcp.json` (no leading dot).
-        const cursorMcp = DEFAULT_MCP_FILENAME.cursor;
-        const dottedMcp = resolve(sourceRoot, ".mcp.json");
-        if (cursorMcp && existsSync(dottedMcp)) {
-            cpSync(dottedMcp, join(targetRoot, cursorMcp), { force: true });
-            rmSync(join(targetRoot, ".mcp.json"), { force: true });
-        }
-    }
-    writeJson(join(targetRoot, platformDir, "plugin.json"), manifest);
-}
-/**
- * Derive a per-surface plugin manifest IN MEMORY from the bundle's canonical
- * Enact manifest. Installs must never write a `.<platform>-plugin/` projection
- * back into the SOURCE bundle dir — the derived manifest is handed to
- * `projectBundle`, which writes it ONLY to the install target.
- *
- * Backward-compat: some legacy bundles ship a pre-derived per-surface manifest
- * (`.codex-plugin/plugin.json`) with NO canonical `.agents/plugin.json`. In that
- * case we fall back to reading the existing per-surface manifest from source —
- * this is a read, not a write, so the source stays clean.
- */
-function deriveTargetManifest(pluginRoot, platform) {
-    const enactManifestPath = join(pluginRoot, ".agents", "plugin.json");
-    if (existsSync(enactManifestPath)) {
-        const enact = readManifestFile(pluginRoot, "enact");
-        return manifestForPlatform(platform, enact);
-    }
-    // Legacy fallback: a per-surface-only bundle (no canonical Enact manifest).
-    const surfaceManifestPath = join(pluginRoot, `.${platform}-plugin`, "plugin.json");
-    if (existsSync(surfaceManifestPath)) {
-        return readManifestFile(pluginRoot, platform);
-    }
-    throw new Error(`Cannot derive ${platform} manifest: no canonical manifest at ${enactManifestPath} ` +
-        `and no ${platform} manifest at ${surfaceManifestPath}`);
-}
-function stringField(manifest, key) {
-    const value = manifest[key];
-    return typeof value === "string" && value.trim() ? value : undefined;
-}
-export function codexMarketplaceRoot(codexHome, marketplaceName = "enact-os-plugins") {
-    return join(codexHome, "marketplaces", marketplaceName);
-}
-export function codexMarketplacePath(codexHome, marketplaceName = "enact-os-plugins") {
-    return join(codexMarketplaceRoot(codexHome, marketplaceName), ".agents", "plugins", "marketplace.json");
-}
-export function codexMarketplacePluginPath(codexHome, marketplaceName, pluginName) {
-    return join(codexMarketplaceRoot(codexHome, marketplaceName), "plugins", pluginName);
-}
-export function codexInstalledPluginPath(codexHome, pluginName) {
-    return join(codexHome, "plugins", pluginName);
-}
-export function codexPluginCachePath(codexHome, marketplaceName, pluginName, version) {
-    return join(codexHome, "plugins", "cache", marketplaceName, pluginName, version);
-}
-export function codexPluginCacheRoot(codexHome, marketplaceName, pluginName) {
-    return join(codexHome, "plugins", "cache", marketplaceName, pluginName);
-}
-export function readCodexPluginManifest(pluginRoot) {
-    const manifestPath = join(pluginRoot, ".codex-plugin", "plugin.json");
-    return readJson(manifestPath, null);
-}
-export function claudeMarketplaceDir(claudeHome, marketplaceName = "enact-os-plugins") {
-    return join(claudeHome, "plugins", "marketplaces", marketplaceName);
-}
-export function claudeInstalledPluginPath(claudeHome, marketplaceName, pluginName) {
-    return join(claudeMarketplaceDir(claudeHome, marketplaceName), "plugins", pluginName);
-}
-export function claudeKnownMarketplacesPath(claudeHome) {
-    return join(claudeHome, "plugins", "known_marketplaces.json");
-}
-export function readClaudePluginManifest(pluginRoot) {
-    const manifestPath = join(pluginRoot, ".claude-plugin", "plugin.json");
-    return readJson(manifestPath, null);
-}
-function marketplaceDisplayName(marketplaceName) {
-    return marketplaceName
-        .split("-")
-        .filter(Boolean)
-        .map((part) => part[0]?.toUpperCase() + part.slice(1))
-        .join(" ");
-}
-function categoryFrom(manifest) {
-    const iface = manifest.interface;
-    if (iface && typeof iface === "object" && !Array.isArray(iface)) {
-        const category = iface.category;
-        if (typeof category === "string" && category.trim())
-            return category;
-    }
-    return "Developer Tools";
-}
-function manifestForCodexInstall(manifest) {
-    return manifest;
-}
-function upsertMarketplaceEntry(codexHome, marketplaceName, manifest, pluginName) {
-    const path = codexMarketplacePath(codexHome, marketplaceName);
-    const current = readJson(path, {
-        name: marketplaceName,
-        interface: { displayName: marketplaceDisplayName(marketplaceName) },
-        plugins: [],
-    });
-    const entry = {
-        name: pluginName,
-        source: { source: "local", path: `./plugins/${pluginName}` },
-        policy: { installation: "AVAILABLE", authentication: "ON_INSTALL" },
-        category: categoryFrom(manifest),
-    };
-    const plugins = (current.plugins ?? []).filter((plugin) => plugin.name !== pluginName);
-    plugins.push(entry);
-    writeJson(path, {
-        name: current.name || marketplaceName,
-        interface: {
-            displayName: current.interface?.displayName || marketplaceDisplayName(marketplaceName),
-        },
-        plugins,
-    });
-    return path;
-}
-export function installCodexPluginBundle(options) {
-    const codexHome = options.codexHome ?? defaultCodexHome();
-    const marketplaceName = options.marketplaceName ?? "enact-os-plugins";
-    // Per-surface manifests are derived IN MEMORY; install never writes to source.
-    const codexManifest = deriveTargetManifest(options.pluginRoot, "codex");
-    const validation = validateCodexManifest(codexManifest);
-    if (!validation.ok) {
-        throw new Error(`Invalid Codex plugin manifest:\n${validation.errors.join("\n")}`);
-    }
-    const componentIssues = checkComponentPaths(options.pluginRoot, codexManifest)
-        .map((issue) => `codex ${issue}`);
-    if (componentIssues.length > 0) {
-        throw new Error(`Plugin component paths are not installable:\n${componentIssues.join("\n")}`);
-    }
-    const name = stringField(codexManifest, "name");
-    if (!name) {
-        throw new Error("Codex plugin manifest is missing name");
-    }
-    const installManifest = manifestForCodexInstall(codexManifest);
-    const version = stringField(codexManifest, "version") ?? "0.0.0";
-    const pluginConfigKey = `${name}@${marketplaceName}`;
-    const config = readCodexConfig(codexHome);
-    ensureMarketplace(config, marketplaceName, {
-        source: codexMarketplaceRoot(codexHome, marketplaceName),
-        source_type: "local",
-    });
-    if (options.enable !== false) {
-        setPluginEnabled(config, pluginConfigKey, true);
-    }
-    const configPath = writeCodexConfig(codexHome, config);
-    const mktPath = upsertMarketplaceEntry(codexHome, marketplaceName, installManifest, name);
-    const mktPluginPath = codexMarketplacePluginPath(codexHome, marketplaceName, name);
-    const installedPath = codexInstalledPluginPath(codexHome, name);
-    const cachePath = codexPluginCachePath(codexHome, marketplaceName, name, version);
-    projectBundle(options.pluginRoot, mktPluginPath, "codex", installManifest, ".codex-plugin");
-    projectBundle(options.pluginRoot, installedPath, "codex", installManifest, ".codex-plugin");
-    projectBundle(options.pluginRoot, cachePath, "codex", installManifest, ".codex-plugin");
-    return {
-        name,
-        version,
-        marketplaceName,
-        pluginConfigKey,
-        configPath,
-        marketplacePath: mktPath,
-        marketplacePluginPath: mktPluginPath,
-        installedPluginPath: installedPath,
-        cachePluginPath: cachePath,
-        refreshedPaths: [mktPluginPath, installedPath, cachePath],
-        syncResults: [],
-    };
-}
-export function installPluginBundle(options) {
-    const codexHomes = resolveCodexInstallHomes({
-        cwd: options.cwd ?? options.pluginRoot,
-        codexHome: options.codexHome,
-    });
-    const results = codexHomes.map((codexHome) => installCodexPluginBundle({
-        ...options,
-        codexHome,
-    }));
-    return { codexHomes, results };
-}
-export function installCodexPluginBundleWithProvision(options) {
-    const result = installCodexPluginBundle(options);
-    const provision = provisionMcp(options.pluginRoot, {
-        noProvision: options.noProvision,
-        exec: options.provisionExec,
-    });
-    return {
-        ...result,
-        provision,
-    };
-}
-export function installPluginBundleWithProvision(options) {
-    const result = installPluginBundle(options);
-    const provision = provisionMcp(options.pluginRoot, {
-        noProvision: options.noProvision,
-        exec: options.provisionExec,
-    });
-    return {
-        ...result,
-        provision,
-    };
-}
-export function codexPluginStatus(codexHome, pluginName, marketplaceName = "enact-os-plugins") {
-    const pluginConfigKey = `${pluginName}@${marketplaceName}`;
-    const installedPath = codexInstalledPluginPath(codexHome, pluginName);
-    const cacheRoot = codexPluginCacheRoot(codexHome, marketplaceName, pluginName);
-    const config = readCodexConfig(codexHome);
-    const cachedVersions = existsSync(cacheRoot)
-        ? readdirSync(cacheRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort()
-        : [];
-    const manifest = existsSync(installedPath) ? readCodexPluginManifest(installedPath) : null;
-    return {
-        name: pluginName,
-        enabled: isPluginEnabled(config, pluginConfigKey),
-        installed: existsSync(installedPath),
-        cachedVersions,
-        manifest,
-        pluginConfigKey,
-        marketplaceName,
-        installedPluginPath: installedPath,
-        marketplacePluginPath: codexMarketplacePluginPath(codexHome, marketplaceName, pluginName),
-        cacheRoot,
-    };
-}
-export function setInstalledCodexPluginEnabled(codexHome, pluginName, enabled, marketplaceName = "enact-os-plugins") {
-    const config = readCodexConfig(codexHome);
-    setPluginEnabled(config, `${pluginName}@${marketplaceName}`, enabled);
-    writeCodexConfig(codexHome, config);
-    return codexPluginStatus(codexHome, pluginName, marketplaceName);
-}
-export function runCodexPluginsDoctor(codexHome = defaultCodexHome(), marketplaceName = "enact-os-plugins") {
-    const config = readCodexConfig(codexHome);
-    const marketplace = readJson(codexMarketplacePath(codexHome, marketplaceName), {
-        name: marketplaceName,
-        interface: { displayName: marketplaceDisplayName(marketplaceName) },
-        plugins: [],
-    });
-    const installedPluginsDir = join(codexMarketplaceRoot(codexHome, marketplaceName), "plugins");
-    const installedPlugins = existsSync(installedPluginsDir)
-        ? readdirSync(installedPluginsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name)
-        : [];
-    const warnings = [];
-    for (const entry of marketplace.plugins) {
-        if (!installedPlugins.includes(entry.name) && isPluginEnabled(config, `${entry.name}@${marketplaceName}`)) {
-            warnings.push(`plugin ${entry.name} enabled in config but not installed locally`);
-        }
-    }
-    return {
-        configPlugins: Object.keys(config.plugins ?? {}).sort(),
-        marketplaceConfigured: Boolean(config.marketplaces?.[marketplaceName]),
-        marketplaceRoot: codexMarketplaceRoot(codexHome, marketplaceName),
-        marketplacePath: codexMarketplacePath(codexHome, marketplaceName),
-        marketplacePlugins: marketplace.plugins.map((plugin) => plugin.name).sort(),
-        installedPlugins: installedPlugins.sort(),
-        warnings,
-    };
-}
-export function installClaudePluginBundle(options) {
-    const claudeHome = options.claudeHome ?? defaultClaudeHome();
-    const marketplaceName = options.marketplaceName ?? "enact-os-plugins";
-    // Per-surface manifest derived IN MEMORY; install never writes to source.
-    const claudeManifest = deriveTargetManifest(options.pluginRoot, "claude");
-    const validation = validateClaudeManifest(claudeManifest);
-    if (!validation.ok) {
-        throw new Error(`Invalid Claude plugin manifest:\n${validation.errors.join("\n")}`);
-    }
-    const name = stringField(claudeManifest, "name");
-    if (!name) {
-        throw new Error("Claude plugin manifest is missing name");
-    }
-    const version = stringField(claudeManifest, "version") ?? "0.0.0";
-    const marketplaceDir = join(claudeHome, "plugins", "marketplaces", marketplaceName);
-    const installedPath = join(marketplaceDir, "plugins", name);
-    projectBundle(options.pluginRoot, installedPath, "claude", claudeManifest, ".claude-plugin");
-    // Claude discovers a directory marketplace's plugins from
-    // <marketplaceDir>/.claude-plugin/marketplace.json. Add/refresh this plugin's
-    // entry (mirrors the codex marketplace.json maintenance).
-    upsertClaudeMarketplaceEntry(marketplaceDir, marketplaceName, name, stringField(claudeManifest, "description"));
-    registerLocalMarketplace(claudeHome, marketplaceName, marketplaceDir);
-    return {
-        name,
-        version,
-        marketplaceName,
-        marketplaceDir,
-        installedPluginPath: installedPath,
-        refreshedPaths: [installedPath],
-        syncResults: [],
-    };
-}
-export function installClaudePluginBundleWithProvision(options) {
-    const result = installClaudePluginBundle(options);
-    const provision = provisionMcp(options.pluginRoot, {
-        noProvision: options.noProvision,
-        exec: options.provisionExec,
-    });
-    return {
-        ...result,
-        provision,
-    };
-}
-export function claudePluginStatus(claudeHome, pluginName, marketplaceName = "enact-os-plugins") {
-    const marketplaceDir = claudeMarketplaceDir(claudeHome, marketplaceName);
-    const knownMarketplaces = readKnownMarketplaces(claudeHome);
-    const installedPath = claudeInstalledPluginPath(claudeHome, marketplaceName, pluginName);
-    const manifest = existsSync(installedPath) ? readClaudePluginManifest(installedPath) : null;
-    const enabledPlugins = readEnabledPlugins(claudeHome);
-    return {
-        name: pluginName,
-        installed: existsSync(installedPath),
-        enabled: Boolean(enabledPlugins[`${pluginName}@${marketplaceName}`]),
-        manifest,
-        marketplaceName,
-        marketplaceDir,
-        installedPluginPath: installedPath,
-        knownMarketplaceRegistered: Boolean(knownMarketplaces[marketplaceName]),
-        knownMarketplacesPath: claudeKnownMarketplacesPath(claudeHome),
-    };
-}
-export function runClaudePluginsDoctor(claudeHome = defaultClaudeHome(), marketplaceName = "enact-os-plugins") {
-    const marketplaceDir = claudeMarketplaceDir(claudeHome, marketplaceName);
-    const knownMarketplaces = readKnownMarketplaces(claudeHome);
-    const enabledPlugins = readEnabledPlugins(claudeHome);
-    const installedPluginsDir = join(marketplaceDir, "plugins");
-    const installedPlugins = existsSync(installedPluginsDir)
-        ? readdirSync(installedPluginsDir, { withFileTypes: true })
-            .filter((entry) => entry.isDirectory())
-            .map((entry) => entry.name)
-        : [];
-    const warnings = [];
-    if (!knownMarketplaces[marketplaceName] && installedPlugins.length > 0) {
-        warnings.push(`marketplace ${marketplaceName} has installed plugins but is not registered in known_marketplaces.json`);
-    }
-    if (knownMarketplaces[marketplaceName] && !existsSync(marketplaceDir)) {
-        warnings.push(`marketplace ${marketplaceName} registered in known_marketplaces.json but install directory is missing`);
-    }
-    return {
-        marketplaceName,
-        marketplaceDir,
-        knownMarketplacesPath: claudeKnownMarketplacesPath(claudeHome),
-        marketplaceRegistered: Boolean(knownMarketplaces[marketplaceName]),
-        marketplacePlugins: installedPlugins.slice().sort(),
-        installedPlugins: installedPlugins.sort(),
-        enabledPlugins: Object.entries(enabledPlugins)
-            .filter(([pluginId, enabled]) => enabled && pluginId.endsWith(`@${marketplaceName}`))
-            .map(([pluginId]) => pluginId.slice(0, -(`@${marketplaceName}`).length))
-            .sort(),
-        warnings,
-    };
-}
-export function installCursorPluginBundle(options) {
-    const cursorHome = options.cursorHome ?? defaultCursorHome();
-    // Per-surface manifest derived IN MEMORY; install never writes to source.
-    const cursorManifest = deriveTargetManifest(options.pluginRoot, "cursor");
-    const validation = validateCursorManifest(cursorManifest);
-    if (!validation.ok) {
-        throw new Error(`Invalid Cursor plugin manifest:\n${validation.errors.join("\n")}`);
-    }
-    const name = stringField(cursorManifest, "name");
-    if (!name) {
-        throw new Error("Cursor plugin manifest is missing name");
-    }
-    const version = stringField(cursorManifest, "version") ?? "0.0.0";
-    const installedPath = join(cursorHome, "plugins", "local", name);
-    projectBundle(options.pluginRoot, installedPath, "cursor", cursorManifest, ".cursor-plugin");
-    return {
-        name,
-        version,
-        installedPluginPath: installedPath,
-        refreshedPaths: [installedPath],
-        syncResults: [],
-    };
-}
-/**
- * Guard: ensure the target path stays within the expected base directory
- * to prevent accidental deletion outside a known home.
- */
-function assertWithinBase(base, target) {
-    const resolvedBase = resolve(base);
-    const resolvedTarget = resolve(target);
-    if (!resolvedTarget.startsWith(resolvedBase + "/") && resolvedTarget !== resolvedBase) {
-        throw new Error(`Safety check failed: resolved path ${resolvedTarget} is not within base ${resolvedBase}`);
-    }
-}
-/**
- * Remove a marketplace.json entry for `pluginName`.
- * If the file doesn't exist or the entry isn't there, this is a no-op.
- * The marketplace registration entry (top-level name/interface fields) is preserved.
- * Other plugin entries are preserved.
- */
-function removeMarketplaceEntry(codexHome, marketplaceName, pluginName) {
-    const path = codexMarketplacePath(codexHome, marketplaceName);
-    if (!existsSync(path))
-        return;
-    const current = readJson(path, { name: marketplaceName, plugins: [] });
-    const filtered = (current.plugins ?? []).filter((p) => p.name !== pluginName);
-    writeJson(path, {
-        name: current.name || marketplaceName,
-        ...(current.interface ? { interface: current.interface } : {}),
-        plugins: filtered,
-    });
-}
-/**
- * Fully uninstall a Codex/Enact plugin from the given home, reversing installCodexPluginBundle:
- * - removes <home>/plugins/<name>/ (installed dir)
- * - removes <home>/marketplaces/<marketplace>/plugins/<name>/ (marketplace plugin dir)
- * - removes <home>/plugins/cache/<marketplace>/<name>/ (cache dir)
- * - removes the plugin's entry from marketplace.json (preserves other entries + marketplace reg)
- * - removes [plugins."<name>@<marketplace>"] from config.toml (preserves [marketplaces.*] etc.)
- */
-export function uninstallCodexPluginBundle(name, options = {}) {
-    const codexHome = options.codexHome ?? defaultCodexHome();
-    const mktName = options.marketplaceName ?? "enact-os-plugins";
-    const pluginConfigKey = `${name}@${mktName}`;
-    const installedPath = codexInstalledPluginPath(codexHome, name);
-    const mktPluginPath = codexMarketplacePluginPath(codexHome, mktName, name);
-    // Cache dir is versioned; remove the entire <cache>/<marketplace>/<name>/ subtree
-    const cacheDirForPlugin = join(codexHome, "plugins", "cache", mktName, name);
-    const noop = !existsSync(installedPath) &&
-        !existsSync(mktPluginPath) &&
-        !existsSync(cacheDirForPlugin);
-    const removedPaths = [];
-    if (existsSync(installedPath)) {
-        assertWithinBase(join(codexHome, "plugins"), installedPath);
-        rmSync(installedPath, { recursive: true, force: true });
-        removedPaths.push(installedPath);
-    }
-    if (existsSync(mktPluginPath)) {
-        assertWithinBase(join(codexHome, "marketplaces"), mktPluginPath);
-        rmSync(mktPluginPath, { recursive: true, force: true });
-        removedPaths.push(mktPluginPath);
-    }
-    if (existsSync(cacheDirForPlugin)) {
-        assertWithinBase(join(codexHome, "plugins", "cache"), cacheDirForPlugin);
-        rmSync(cacheDirForPlugin, { recursive: true, force: true });
-        removedPaths.push(cacheDirForPlugin);
-    }
-    // Remove plugin entry from marketplace.json (leave file + other entries intact)
-    removeMarketplaceEntry(codexHome, mktName, name);
-    // Remove [plugins."<name>@<marketplace>"] from config.toml (leave marketplaces.* intact)
-    const config = readCodexConfig(codexHome);
-    removePluginConfig(config, pluginConfigKey);
-    if (existsSync(join(codexHome, "config.toml"))) {
-        writeCodexConfig(codexHome, config);
-    }
-    return { name, marketplaceName: mktName, removedPaths, noop };
-}
-/**
- * Fully uninstall a Claude plugin, reversing installClaudePluginBundle:
- * - removes <claudeHome>/plugins/marketplaces/<marketplace>/plugins/<name>/
- * Note: the marketplace registration in known_marketplaces.json is LEFT intact
- * (the marketplace itself persists even after its last plugin is removed).
- */
-export function uninstallClaudePluginBundle(name, options = {}) {
-    const claudeHome = options.claudeHome ?? defaultClaudeHome();
-    const mktName = options.marketplaceName ?? "enact-os-plugins";
-    const marketplaceDir = join(claudeHome, "plugins", "marketplaces", mktName);
-    const installedPath = join(marketplaceDir, "plugins", name);
-    const noop = !existsSync(installedPath);
-    const removedPaths = [];
-    if (existsSync(installedPath)) {
-        assertWithinBase(marketplaceDir, installedPath);
-        rmSync(installedPath, { recursive: true, force: true });
-        removedPaths.push(installedPath);
-    }
-    // Remove this plugin's entry from the marketplace.json (leave the file, the
-    // marketplace registration, and other plugin entries intact).
-    removeClaudeMarketplaceEntry(marketplaceDir, mktName, name);
-    return { name, removedPaths, noop };
-}
-/**
- * Fully uninstall a Cursor plugin, reversing installCursorPluginBundle:
- * - removes <cursorHome>/plugins/local/<name>/
- */
-export function uninstallCursorPluginBundle(name, options = {}) {
-    const cursorHome = options.cursorHome ?? defaultCursorHome();
-    const installedPath = join(cursorHome, "plugins", "local", name);
-    const noop = !existsSync(installedPath);
-    const removedPaths = [];
-    if (existsSync(installedPath)) {
-        assertWithinBase(join(cursorHome, "plugins", "local"), installedPath);
-        rmSync(installedPath, { recursive: true, force: true });
-        removedPaths.push(installedPath);
-    }
-    return { name, removedPaths, noop };
-}
-/**
- * Default global shared home base. The convention is that skills live at
- * `~/.agents/skills/<plugin>/`, so this returns `homedir()` and the install
- * function appends `.agents/skills/<name>`.
- *
- * Pass an explicit `sharedHome` to override (useful in tests or local scope).
- */
-export function defaultSharedHome() {
-    return homedir();
-}
-/**
- * Install the bundle's skills tree into <sharedHome>/.agents/skills/<plugin>/.
- * Does NOT write a marketplace entry, config.toml, or any platform-specific
- * manifest — this is a pure host-neutral skills drop that any host reading
- * `.agents/skills/` (Codex, Cursor, Gemini, etc.) can pick up.
- */
-export function installSharedPluginBundle(options) {
-    const sharedHome = options.sharedHome ?? defaultSharedHome();
-    // Read the enact manifest for name/version; fall back to codex if no enact manifest.
-    const enactManifestPath = join(options.pluginRoot, ".agents", "plugin.json");
-    let manifest;
-    if (existsSync(enactManifestPath)) {
-        manifest = readManifestFile(options.pluginRoot, "enact");
-    }
-    else {
-        manifest = readManifestFile(options.pluginRoot, "codex");
-    }
-    const name = stringField(manifest, "name");
-    if (!name) {
-        throw new Error("Plugin manifest is missing name");
-    }
-    const version = stringField(manifest, "version") ?? "0.0.0";
-    // Resolve the skills source path from the manifest
-    const rawSkills = stringField(manifest, "skills");
-    if (!rawSkills) {
-        throw new Error(`Plugin manifest for '${name}' has no 'skills' field — nothing to install for shared target`);
-    }
-    const cleanedSkills = rawSkills.replace(/^\.\//, "").replace(/\/+$/, "");
-    const skillsSource = resolve(options.pluginRoot, cleanedSkills);
-    // shared is a skills-only surface: a missing skills source is misuse.
-    // Fail loudly before touching the target rather than producing an empty dir.
-    if (!existsSync(skillsSource)) {
-        throw new Error(`Cannot install shared bundle "${name}": skills source not found at ${skillsSource}`);
-    }
-    // Target: <sharedHome>/.agents/skills/<name>/
-    const installedSkillsPath = join(sharedHome, ".agents", "skills", name);
-    rmSync(installedSkillsPath, { recursive: true, force: true });
-    mkdirSync(installedSkillsPath, { recursive: true });
-    cpSync(skillsSource, installedSkillsPath, { recursive: true, force: true });
-    return {
-        name,
-        version,
-        installedSkillsPath,
-    };
-}
-/**
- * Uninstall a shared plugin by removing its skills directory.
- * Reverses installSharedPluginBundle.
- */
-export function uninstallSharedPluginBundle(name, options = {}) {
-    const sharedHome = options.sharedHome ?? defaultSharedHome();
-    const installedSkillsPath = join(sharedHome, ".agents", "skills", name);
-    const noop = !existsSync(installedSkillsPath);
-    const removedPaths = [];
-    if (existsSync(installedSkillsPath)) {
-        assertWithinBase(join(sharedHome, ".agents", "skills"), installedSkillsPath);
-        rmSync(installedSkillsPath, { recursive: true, force: true });
-        removedPaths.push(installedSkillsPath);
-    }
-    return { name, installedSkillsPath, removedPaths, noop };
-}
-//# sourceMappingURL=install.js.map