@amsterdamdatalabs/enact-extensions 0.1.0 → 0.1.3

package/dist/install.js

@@ -1,10 +1,13 @@
-import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { defaultCodexHome, ensureMarketplace, readCodexConfig, resolveCodexInstallHomes, setPluginEnabled, writeCodexConfig, } from "./internal/codex.js";
-import { syncPlatformManifests } from "./create/index.js";
-import { checkPluginBundleComponentPaths, readManifestFile, validateClaudeManifest, validateCodexManifest, validateCursorManifest, } from "./validate/index.js";
-import { defaultClaudeHome, registerLocalMarketplace } from "./internal/claude.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 { PROJECTION_COMPONENT_FIELDS } from "./internal/platform.js";
+import { checkComponentPaths, readManifestFile, validateClaudeManifest, validateCodexManifest, validateCursorManifest, } from "./validate/index.js";
+import { defaultClaudeHome, readKnownMarketplaces, registerLocalMarketplace } from "./internal/claude.js";
 import { defaultCursorHome } from "./internal/cursor.js";
+import { provisionMcp } from "./provision.js";
 function readJson(path, fallback) {
     if (!existsSync(path))
         return fallback;
@@ -14,14 +17,19 @@ function writeJson(path, value) {
     mkdirSync(dirname(path), { recursive: true });
     writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
 }
-function pathFieldsFromManifest(manifest) {
-    const fields = ["skills", "mcpServers", "apps", "commands", "hooks", "agents", "_agents", "rules"];
+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"]) {
@@ -32,9 +40,9 @@ function pathFieldsFromManifest(manifest) {
     }
     return results;
 }
-function normalizedProjectionEntries(manifest, platformDir) {
+function normalizedProjectionEntries(platform, manifest, platformDir) {
     const entries = new Set([platformDir, "README.md"]);
-    for (const raw of pathFieldsFromManifest(manifest)) {
+    for (const raw of pathFieldsFromManifest(platform, manifest)) {
         const cleaned = raw.replace(/^\.\//, "").replace(/\/+$/, "");
         if (!cleaned || cleaned.startsWith("../"))
             continue;
@@ -50,10 +58,10 @@ function normalizedProjectionEntries(manifest, platformDir) {
     }
     return [...entries];
 }
-function projectBundle(sourceRoot, targetRoot, manifest, platformDir) {
+function projectBundle(sourceRoot, targetRoot, platform, manifest, platformDir) {
     rmSync(targetRoot, { recursive: true, force: true });
     mkdirSync(targetRoot, { recursive: true });
-    for (const entry of normalizedProjectionEntries(manifest, platformDir)) {
+    for (const entry of normalizedProjectionEntries(platform, manifest, platformDir)) {
         const sourcePath = resolve(sourceRoot, entry);
         if (!existsSync(sourcePath))
             continue;
@@ -61,32 +69,70 @@ function projectBundle(sourceRoot, targetRoot, manifest, platformDir) {
     }
     writeJson(join(targetRoot, platformDir, "plugin.json"), manifest);
 }
-function maybeSync(pluginRoot, platform) {
+/**
+ * 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))
-        return [];
-    const enact = readManifestFile(pluginRoot, "enact");
-    return syncPlatformManifests(pluginRoot, enact, [platform]);
+    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;
 }
-function marketplaceRoot(codexHome, marketplaceName) {
+export function codexMarketplaceRoot(codexHome, marketplaceName = "enact-os-plugins") {
     return join(codexHome, "marketplaces", marketplaceName);
 }
-function marketplacePath(codexHome, marketplaceName) {
-    return join(marketplaceRoot(codexHome, marketplaceName), ".agents", "plugins", "marketplace.json");
+export function codexMarketplacePath(codexHome, marketplaceName = "enact-os-plugins") {
+    return join(codexMarketplaceRoot(codexHome, marketplaceName), ".agents", "plugins", "marketplace.json");
 }
-function marketplacePluginPath(codexHome, marketplaceName, pluginName) {
-    return join(marketplaceRoot(codexHome, marketplaceName), "plugins", pluginName);
+export function codexMarketplacePluginPath(codexHome, marketplaceName, pluginName) {
+    return join(codexMarketplaceRoot(codexHome, marketplaceName), "plugins", pluginName);
 }
-function installedPluginPath(codexHome, pluginName) {
+export function codexInstalledPluginPath(codexHome, pluginName) {
     return join(codexHome, "plugins", pluginName);
 }
-function cachePluginPath(codexHome, marketplaceName, pluginName, version) {
+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("-")
@@ -104,15 +150,10 @@ function categoryFrom(manifest) {
     return "Developer Tools";
 }
 function manifestForCodexInstall(manifest) {
-    const name = stringField(manifest, "name");
-    if (name !== "enact-operator" && name !== "enact-extensions")
-        return manifest;
-    const clone = { ...manifest };
-    delete clone.hooks;
-    return clone;
+    return manifest;
 }
 function upsertMarketplaceEntry(codexHome, marketplaceName, manifest, pluginName) {
-    const path = marketplacePath(codexHome, marketplaceName);
+    const path = codexMarketplacePath(codexHome, marketplaceName);
     const current = readJson(path, {
         name: marketplaceName,
         interface: { displayName: marketplaceDisplayName(marketplaceName) },
@@ -138,13 +179,14 @@ function upsertMarketplaceEntry(codexHome, marketplaceName, manifest, pluginName
 export function installCodexPluginBundle(options) {
     const codexHome = options.codexHome ?? defaultCodexHome();
     const marketplaceName = options.marketplaceName ?? "enact-os-plugins";
-    const syncResults = options.sync !== false ? maybeSync(options.pluginRoot, "codex") : [];
-    const codexManifest = readManifestFile(options.pluginRoot, "codex");
+    // 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 = checkPluginBundleComponentPaths(options.pluginRoot, ["codex"]);
+    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")}`);
     }
@@ -157,7 +199,7 @@ export function installCodexPluginBundle(options) {
     const pluginConfigKey = `${name}@${marketplaceName}`;
     const config = readCodexConfig(codexHome);
     ensureMarketplace(config, marketplaceName, {
-        source: marketplaceRoot(codexHome, marketplaceName),
+        source: codexMarketplaceRoot(codexHome, marketplaceName),
         source_type: "local",
     });
     if (options.enable !== false) {
@@ -165,12 +207,12 @@ export function installCodexPluginBundle(options) {
     }
     const configPath = writeCodexConfig(codexHome, config);
     const mktPath = upsertMarketplaceEntry(codexHome, marketplaceName, installManifest, name);
-    const mktPluginPath = marketplacePluginPath(codexHome, marketplaceName, name);
-    const installedPath = installedPluginPath(codexHome, name);
-    const cachePath = cachePluginPath(codexHome, marketplaceName, name, version);
-    projectBundle(options.pluginRoot, mktPluginPath, installManifest, ".codex-plugin");
-    projectBundle(options.pluginRoot, installedPath, installManifest, ".codex-plugin");
-    projectBundle(options.pluginRoot, cachePath, installManifest, ".codex-plugin");
+    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,
@@ -182,7 +224,7 @@ export function installCodexPluginBundle(options) {
         installedPluginPath: installedPath,
         cachePluginPath: cachePath,
         refreshedPaths: [mktPluginPath, installedPath, cachePath],
-        syncResults,
+        syncResults: [],
     };
 }
 export function installPluginBundle(options) {
@@ -196,11 +238,88 @@ export function installPluginBundle(options) {
     }));
     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";
-    const syncResults = options.sync !== false ? maybeSync(options.pluginRoot, "claude") : [];
-    const claudeManifest = readManifestFile(options.pluginRoot, "claude");
+    // 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")}`);
@@ -212,7 +331,7 @@ export function installClaudePluginBundle(options) {
     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, claudeManifest, ".claude-plugin");
+    projectBundle(options.pluginRoot, installedPath, "claude", claudeManifest, ".claude-plugin");
     registerLocalMarketplace(claudeHome, marketplaceName, marketplaceDir);
     return {
         name,
@@ -221,13 +340,66 @@ export function installClaudePluginBundle(options) {
         marketplaceDir,
         installedPluginPath: installedPath,
         refreshedPaths: [installedPath],
-        syncResults,
+        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;
+    return {
+        name: pluginName,
+        installed: existsSync(installedPath),
+        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 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(),
+        warnings,
     };
 }
 export function installCursorPluginBundle(options) {
     const cursorHome = options.cursorHome ?? defaultCursorHome();
-    const syncResults = options.sync !== false ? maybeSync(options.pluginRoot, "cursor") : [];
-    const cursorManifest = readManifestFile(options.pluginRoot, "cursor");
+    // 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")}`);
@@ -238,13 +410,194 @@ export function installCursorPluginBundle(options) {
     }
     const version = stringField(cursorManifest, "version") ?? "0.0.0";
     const installedPath = join(cursorHome, "plugins", "local", name);
-    projectBundle(options.pluginRoot, installedPath, cursorManifest, ".cursor-plugin");
+    projectBundle(options.pluginRoot, installedPath, "cursor", cursorManifest, ".cursor-plugin");
     return {
         name,
         version,
         installedPluginPath: installedPath,
         refreshedPaths: [installedPath],
-        syncResults,
+        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);
+    }
+    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