@ken-jo/agent-connector 0.2.0 → 0.3.0

package/dist/chunk-QADSG2JY.js

@@ -0,0 +1,1989 @@
+#!/usr/bin/env node
+import {
+  installInstructions,
+  packageConnector
+} from "./chunk-WNREHWKL.js";
+import {
+  MARKETPLACE_NAME,
+  agyPluginInstalled,
+  agyStagingRoot,
+  anyClaudeAgentConnectorPlugins,
+  anyCodexAgentConnectorPlugins,
+  anyMarketplaceRecordsRemain,
+  claudeKnownMarketplacePath,
+  claudePluginInstalled,
+  claudePluginKey,
+  claudeStagingRoot,
+  codexMarketplaceSource,
+  codexPluginInstalled,
+  codexPluginKey,
+  codexStagingRoot,
+  connectorHasMarketplaceRecords,
+  hashDirectory,
+  marketplaceEvidence,
+  marketplaceRoot,
+  readMarketplaceInstalls,
+  writeMarketplaceInstalls
+} from "./chunk-44HUXXC6.js";
+import {
+  log,
+  spawnChild
+} from "./chunk-KVAAFYRR.js";
+import {
+  REGISTERED_PLATFORM_IDS,
+  detectInstalledPlatforms,
+  loadAdapter
+} from "./chunk-NJU275US.js";
+import {
+  deregisterConnector,
+  loadRegisteredConnector,
+  registerConnector
+} from "./chunk-3JCRUROU.js";
+import {
+  configPatchManualEdit
+} from "./chunk-GSGDG2BV.js";
+import {
+  hasMemoryLedger
+} from "./chunk-N6HH7K6P.js";
+import {
+  connectorDir,
+  connectorsDir,
+  dataRoot,
+  ensureDir,
+  ensureHomeBin,
+  homeBinPath
+} from "./chunk-TRQKHP7D.js";
+
+// src/core/installer.ts
+import { existsSync, readdirSync, rmSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+async function installConnector(opts) {
+  const { connector, modulePath, scope, projectDir, dryRun, force } = opts;
+  if (!dryRun) {
+    try {
+      ensureHomeBin(resolveCliEntry());
+    } catch (err) {
+      log.warn(`ensureHomeBin failed: ${errMessage(err)}`);
+    }
+    try {
+      registerConnector(connector, modulePath);
+    } catch (err) {
+      log.warn(`registerConnector failed: ${errMessage(err)}`);
+    }
+  }
+  const targets = await resolveTargets(opts.targets, connector.targets, projectDir);
+  const result = newResult(connector.id, dryRun);
+  if (targets.length === 0) {
+    result.warnings.push(
+      "no target platforms resolved (none installed / detected, or all filtered out)"
+    );
+    return result;
+  }
+  for (const id of targets) {
+    const evidence = marketplaceEvidence(connector.id, id);
+    if (evidence) {
+      const detail = `"${connector.id}" is already installed via MARKETPLACE on ${id} (${evidence}) \u2014 refusing the direct install. Run \`agent-connector uninstall --method marketplace --targets ${id}\` first, or keep the marketplace install.`;
+      result.changes.push({ platform: id, action: "warn", detail });
+      result.warnings.push(detail);
+      continue;
+    }
+    const adapter = await tryLoadAdapter(id, result);
+    if (!adapter) continue;
+    const ctx = buildContext(connector, id, scope, projectDir, dryRun, force);
+    if (!dryRun) {
+      runStep(id, "backupSettings", result, () => {
+        const backup = adapter.backupSettings(ctx);
+        if (backup) {
+          result.changes.push({
+            platform: id,
+            action: "create",
+            path: backup,
+            detail: "backed up settings before install"
+          });
+        }
+      });
+    }
+    runStep(id, "installServer", result, () => {
+      pushAll(result.changes, adapter.installServer(ctx));
+    });
+    runStep(id, "installHooks", result, () => {
+      pushAll(result.changes, adapter.installHooks(ctx));
+    });
+    const nativeHooks = connector.platforms[id]?.nativeHooks;
+    const nativeCount = nativeHooks ? Object.keys(nativeHooks).length : 0;
+    if (nativeCount > 0 && !(adapter.capabilities.supportsNativeHooks ?? false)) {
+      result.changes.push({
+        platform: id,
+        action: "warn",
+        detail: `nativeHooks not supported on ${id}; ${nativeCount} skipped`
+      });
+    }
+    if (connector.commands.length) {
+      runStep(id, "installCommands", result, () => {
+        pushAll(result.changes, adapter.installCommands(ctx));
+      });
+    }
+    if (connector.skills.length) {
+      runStep(id, "installSkills", result, () => {
+        pushAll(result.changes, adapter.installSkills(ctx));
+      });
+    }
+    if (connector.subagents.length) {
+      runStep(id, "installSubagents", result, () => {
+        pushAll(result.changes, adapter.installSubagents(ctx));
+      });
+    }
+    if ((connector.memory ?? []).length) {
+      runStep(id, "installMemory", result, () => {
+        pushAll(result.changes, adapter.installMemory(ctx));
+      });
+    }
+    const configPatches = connector.platforms[id]?.configPatch ?? [];
+    if (configPatches.length > 0) {
+      if (adapter.capabilities.supportsConfigPatch ?? false) {
+        runStep(id, "installConfigPatches", result, () => {
+          pushAll(result.changes, adapter.installConfigPatches(ctx));
+        });
+      } else {
+        result.changes.push({
+          platform: id,
+          action: "warn",
+          detail: `configPatch not supported on ${id}; ${configPatches.length} skipped`
+        });
+        for (const patch of configPatches) {
+          result.changes.push({
+            platform: id,
+            action: "warn",
+            detail: `configPatch ${patch.key} skipped on ${id} \u2014 ${configPatchManualEdit(patch)}`
+          });
+        }
+      }
+    }
+  }
+  return result;
+}
+async function syncConnector(opts) {
+  return installConnector(opts);
+}
+async function uninstallConnector(opts) {
+  const { connectorId, scope, projectDir, dryRun, purge } = opts;
+  const connector = await loadConnectorForUninstall(connectorId);
+  const result = newResult(connectorId, dryRun);
+  const targets = await resolveTargets(opts.targets, connector.targets, projectDir);
+  if (targets.length === 0) {
+    result.warnings.push(
+      "no target platforms resolved for uninstall (none installed / detected, or all filtered out)"
+    );
+    if (purge) purgeFrameworkState(connectorId, dryRun, result);
+    return result;
+  }
+  for (const id of targets) {
+    const adapter = await tryLoadAdapter(id, result);
+    if (!adapter) continue;
+    const ctx = buildContext(connector, id, scope, projectDir, dryRun);
+    if (adapter.capabilities.supportsConfigPatch ?? false) {
+      runStep(id, "uninstallConfigPatches", result, () => {
+        pushAll(result.changes, adapter.uninstallConfigPatches(ctx));
+      });
+    }
+    if ((connector.memory ?? []).length > 0 || hasMemoryLedger(connector.id)) {
+      runStep(id, "uninstallMemory", result, () => {
+        pushAll(result.changes, adapter.uninstallMemory(ctx));
+      });
+    }
+    if (connector.subagents.length) {
+      runStep(id, "uninstallSubagents", result, () => {
+        pushAll(result.changes, adapter.uninstallSubagents(ctx));
+      });
+    }
+    if (connector.commands.length) {
+      runStep(id, "uninstallCommands", result, () => {
+        pushAll(result.changes, adapter.uninstallCommands(ctx));
+      });
+    }
+    if (connector.skills.length) {
+      runStep(id, "uninstallSkills", result, () => {
+        pushAll(result.changes, adapter.uninstallSkills(ctx));
+      });
+    }
+    runStep(id, "uninstallHooks", result, () => {
+      pushAll(result.changes, adapter.uninstallHooks(ctx));
+    });
+    runStep(id, "uninstallServer", result, () => {
+      pushAll(result.changes, adapter.uninstallServer(ctx));
+    });
+  }
+  if (purge) purgeFrameworkState(connectorId, dryRun, result);
+  return result;
+}
+function purgeFrameworkState(connectorId, dryRun, result) {
+  const platform = connectorId;
+  if (connectorHasMarketplaceRecords(connectorId)) {
+    const detail = `--purge skipped: "${connectorId}" still records marketplace installs \u2014 run \`agent-connector uninstall --method marketplace\` first`;
+    result.changes.push({ platform, action: "warn", detail });
+    result.warnings.push(detail);
+    return;
+  }
+  const recordDir = connectorDir(connectorId);
+  const recordExisted = existsSync(recordDir);
+  if (recordExisted) {
+    if (!dryRun) {
+      try {
+        deregisterConnector(connectorId);
+      } catch (err) {
+        log.warn(`deregisterConnector failed: ${errMessage(err)}`);
+      }
+    }
+    result.changes.push({
+      platform,
+      action: "remove",
+      path: recordDir,
+      detail: "deregistered connector record"
+    });
+  }
+  if (anyMarketplaceRecordsRemain(connectorId)) {
+    return;
+  }
+  if (noConnectorsRemain(connectorId, dryRun, recordExisted)) {
+    const binPath = homeBinPath();
+    if (existsSync(binPath)) {
+      if (!dryRun) {
+        try {
+          rmSync(binPath, { force: true });
+        } catch (err) {
+          log.warn(`home-bin removal failed: ${errMessage(err)}`);
+        }
+      }
+      result.changes.push({
+        platform,
+        action: "remove",
+        path: binPath,
+        detail: "removed home-bin (no connectors remain)"
+      });
+    }
+  }
+}
+function noConnectorsRemain(connectorId, dryRun, recordExisted) {
+  const dir = connectorsDir();
+  if (!existsSync(dir)) return true;
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return false;
+  }
+  const remaining = entries.filter(
+    (e) => !(dryRun && recordExisted && e === connectorId)
+  );
+  return remaining.length === 0;
+}
+function resolveCliEntry() {
+  try {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 8; i++) {
+      if (existsSync(join(dir, "package.json"))) {
+        const cli = join(dir, "dist", "cli.js");
+        if (existsSync(cli)) return cli;
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    const sameDir = fileURLToPath(new URL("./cli.js", import.meta.url));
+    if (existsSync(sameDir)) return sameDir;
+  } catch {
+  }
+  const argv1 = process.argv[1];
+  if (argv1 && argv1.length > 0) return argv1;
+  return "cli.js";
+}
+async function resolveTargets(flagTargets, connectorTargets, projectDir) {
+  let requested;
+  if (flagTargets && flagTargets.length > 0) {
+    requested = flagTargets;
+  } else if (Array.isArray(connectorTargets) && connectorTargets.length > 0) {
+    requested = connectorTargets;
+  } else {
+    requested = await autoDetectIds(projectDir);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const id of requested) {
+    if (!REGISTERED_PLATFORM_IDS.has(id)) continue;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+  }
+  return out;
+}
+async function autoDetectIds(projectDir) {
+  try {
+    const detected = await detectInstalledPlatforms(projectDir);
+    return detected.filter((p) => p.installed).map((p) => p.id);
+  } catch (err) {
+    log.warn(`platform detection failed: ${errMessage(err)}`);
+    return [];
+  }
+}
+function buildContext(connector, id, defaultScope, projectDir, dryRun, force = false) {
+  return {
+    connector,
+    scope: connector.platforms[id]?.scope ?? defaultScope,
+    projectDir,
+    homeBinPath: homeBinPath(),
+    dataRoot: dataRoot(),
+    dryRun,
+    force
+  };
+}
+async function tryLoadAdapter(id, result) {
+  try {
+    const adapter = await loadAdapter(id);
+    if (adapter) return adapter;
+    const detail = `no adapter registered for ${id}`;
+    result.changes.push({ platform: id, action: "warn", detail });
+    result.warnings.push(detail);
+    return null;
+  } catch (err) {
+    const detail = `failed to load adapter for ${id}: ${errMessage(err)}`;
+    result.changes.push({ platform: id, action: "warn", detail });
+    result.warnings.push(detail);
+    return null;
+  }
+}
+function runStep(id, step, result, fn) {
+  try {
+    fn();
+  } catch (err) {
+    const detail = `${step} failed on ${id}: ${errMessage(err)}`;
+    result.changes.push({ platform: id, action: "warn", detail });
+    result.warnings.push(detail);
+  }
+}
+async function resolveUninstallTargets(connectorId, flagTargets, projectDir) {
+  const connector = await loadConnectorForUninstall(connectorId);
+  return resolveTargets(flagTargets, connector.targets, projectDir);
+}
+async function loadConnectorForUninstall(connectorId) {
+  try {
+    return await loadRegisteredConnector(connectorId);
+  } catch (err) {
+    log.warn(
+      `could not load registered connector "${connectorId}" for uninstall (${errMessage(err)}); proceeding with a minimal id-only context`
+    );
+    return syntheticConnector(connectorId);
+  }
+}
+function syntheticConnector(id) {
+  return {
+    id,
+    displayName: id,
+    version: "0.0.0",
+    hooks: {},
+    hookEvents: [],
+    telemetry: {
+      enabled: true,
+      modelFamilyHint: "auto",
+      measureToolDefs: true,
+      hostNativeUsage: false,
+      store: "ndjson",
+      calibration: { anthropicCountTokens: false }
+    },
+    commands: [],
+    skills: [],
+    subagents: [],
+    memory: [],
+    platforms: {},
+    targets: "auto"
+  };
+}
+function newResult(connectorId, dryRun) {
+  return { connectorId, dryRun, changes: [], warnings: [] };
+}
+function pushAll(target, records) {
+  for (const r of records) target.push(r);
+}
+function errMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/core/marketplace.ts
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync3, rmSync as rmSync5 } from "fs";
+import { join as join6 } from "path";
+
+// src/core/marketplace-drivers/claude.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync, rmSync as rmSync2, writeFileSync } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+
+// src/core/marketplace-drivers/shared.ts
+import { existsSync as existsSync2, statSync } from "fs";
+import { delimiter, join as join2, resolve } from "path";
+var HOST_COMMAND_TIMEOUT_MS = 3e4;
+function findOnPath(command) {
+  const pathVar = process.env.PATH ?? "";
+  const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").concat("") : [""];
+  for (const dir of pathVar.split(delimiter)) {
+    if (dir === "") continue;
+    for (const ext of exts) {
+      const candidate = join2(dir, command + ext.toLowerCase());
+      try {
+        if (existsSync2(candidate) && statSync(candidate).isFile()) {
+          return candidate;
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function runHostCommand(command, args, timeoutMs = HOST_COMMAND_TIMEOUT_MS) {
+  return new Promise((resolvePromise) => {
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let settled = false;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolvePromise(result);
+    };
+    let child;
+    try {
+      child = spawnChild(command, args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: process.env
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      resolvePromise({
+        ok: false,
+        code: null,
+        stdout: "",
+        stderr: "",
+        timedOut: false,
+        error: message
+      });
+      return;
+    }
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (err) => {
+      settle({
+        ok: false,
+        code: null,
+        stdout,
+        stderr,
+        timedOut,
+        error: err.message
+      });
+    });
+    child.on("close", (code) => {
+      settle({
+        ok: code === 0 && !timedOut,
+        code,
+        stdout,
+        stderr,
+        timedOut
+      });
+    });
+  });
+}
+function firstLine(text) {
+  const line = text.split(/\r?\n/).find((l) => l.trim() !== "");
+  return line ? line.trim() : "";
+}
+function samePath(a, b) {
+  if (a == null || b == null) return false;
+  const norm = (p) => {
+    let s = p;
+    if (process.platform === "win32") {
+      s = s.replace(/^\\\\\?\\UNC\\/, "\\\\").replace(/^\\\\\?\\/, "");
+    }
+    s = resolve(s);
+    return process.platform === "win32" ? s.toLowerCase() : s;
+  };
+  return norm(a) === norm(b);
+}
+
+// src/core/marketplace-drivers/claude.ts
+var PLATFORM = "claude-code";
+function claudeBinary() {
+  return findOnPath("claude");
+}
+function claudeManualInstallCommands(connectorId, stagingRoot) {
+  return `claude plugin marketplace add ${stagingRoot} && claude plugin install ${claudePluginKey(connectorId)}`;
+}
+function warn(detail, path) {
+  return { platform: PLATFORM, action: "warn", detail, ...path ? { path } : {} };
+}
+function failDetail(step, r) {
+  if (r.timedOut) return `${step} timed out`;
+  if (r.error) return `${step} failed to spawn: ${r.error}`;
+  const line = firstLine(r.stderr) || firstLine(r.stdout);
+  return `${step} exited ${r.code}${line ? `: ${line}` : ""}`;
+}
+async function claudeDriveInstall(connectorId, stagingRoot, pluginDir) {
+  const changes = [];
+  const pluginKey = claudePluginKey(connectorId);
+  const bin = claudeBinary();
+  if (!bin) {
+    changes.push(
+      warn(
+        `claude CLI not found on PATH \u2014 bundle staged but not installed. Install manually: ${claudeManualInstallCommands(connectorId, stagingRoot)}`,
+        stagingRoot
+      )
+    );
+    return { changes, installed: false };
+  }
+  const validation = await runHostCommand(bin, ["plugin", "validate", pluginDir]);
+  if (!validation.ok && !validation.error) {
+    changes.push(
+      warn(
+        `bundle failed \`claude plugin validate\` \u2014 not installing. ` + failDetail("validate", validation),
+        pluginDir
+      )
+    );
+    return { changes, installed: false };
+  }
+  const registeredAt = claudeKnownMarketplacePath(MARKETPLACE_NAME);
+  if (registeredAt === stagingRoot) {
+    changes.push({
+      platform: PLATFORM,
+      action: "skip",
+      path: stagingRoot,
+      detail: `marketplace "${MARKETPLACE_NAME}" already registered`
+    });
+  } else if (registeredAt != null) {
+    changes.push(
+      warn(
+        `a marketplace named "${MARKETPLACE_NAME}" is already registered at ${registeredAt} (not ours) \u2014 refusing to touch it. Remove it first (claude plugin marketplace remove ${MARKETPLACE_NAME}) or install manually: ` + claudeManualInstallCommands(connectorId, stagingRoot)
+      )
+    );
+    return { changes, installed: false };
+  } else {
+    const add = await runHostCommand(bin, [
+      "plugin",
+      "marketplace",
+      "add",
+      stagingRoot
+    ]);
+    if (!add.ok) {
+      changes.push(
+        warn(
+          `could not register the local marketplace \u2014 ` + failDetail("claude plugin marketplace add", add) + `. Install manually: ${claudeManualInstallCommands(connectorId, stagingRoot)}`,
+          stagingRoot
+        )
+      );
+      return { changes, installed: false };
+    }
+    changes.push({
+      platform: PLATFORM,
+      action: "create",
+      path: stagingRoot,
+      detail: `registered local marketplace "${MARKETPLACE_NAME}" (claude plugin marketplace add)`
+    });
+  }
+  if (claudePluginInstalled(connectorId)) {
+    changes.push({
+      platform: PLATFORM,
+      action: "skip",
+      detail: `plugin ${pluginKey} already installed`
+    });
+    return { changes, installed: true };
+  }
+  const install = await runHostCommand(bin, ["plugin", "install", pluginKey]);
+  if (!install.ok || !claudePluginInstalled(connectorId)) {
+    changes.push(
+      warn(
+        `plugin install did not complete \u2014 ` + failDetail(`claude plugin install ${pluginKey}`, install)
+      )
+    );
+    return { changes, installed: false };
+  }
+  changes.push({
+    platform: PLATFORM,
+    action: "create",
+    detail: `installed plugin ${pluginKey} (scope user)`
+  });
+  return { changes, installed: true };
+}
+async function claudeDriveUninstall(connectorId) {
+  const changes = [];
+  const pluginKey = claudePluginKey(connectorId);
+  if (!claudePluginInstalled(connectorId)) {
+    changes.push({
+      platform: PLATFORM,
+      action: "skip",
+      detail: `plugin ${pluginKey} not installed on claude-code`
+    });
+    return { changes, removed: true };
+  }
+  const bin = claudeBinary();
+  if (!bin) {
+    changes.push(
+      warn(
+        `claude CLI not found on PATH \u2014 cannot drive the uninstall. Run manually: claude plugin uninstall ${pluginKey}`
+      )
+    );
+    return { changes, removed: false };
+  }
+  const uninstall = await runHostCommand(bin, ["plugin", "uninstall", pluginKey]);
+  if (!uninstall.ok || claudePluginInstalled(connectorId)) {
+    changes.push(
+      warn(`plugin uninstall did not complete \u2014 ` + failDetail(`claude plugin uninstall ${pluginKey}`, uninstall))
+    );
+    return { changes, removed: false };
+  }
+  changes.push({
+    platform: PLATFORM,
+    action: "remove",
+    detail: `uninstalled plugin ${pluginKey} (claude plugin uninstall)`
+  });
+  return { changes, removed: true };
+}
+async function claudeDriveMarketplaceRemove(stagingRoot) {
+  const bin = claudeBinary();
+  if (!bin) {
+    return [
+      warn(
+        `claude CLI not found on PATH \u2014 marketplace registration "${MARKETPLACE_NAME}" left behind. Run manually: claude plugin marketplace remove ${MARKETPLACE_NAME}`,
+        stagingRoot
+      )
+    ];
+  }
+  const remove = await runHostCommand(bin, [
+    "plugin",
+    "marketplace",
+    "remove",
+    MARKETPLACE_NAME
+  ]);
+  if (!remove.ok) {
+    return [
+      warn(
+        `could not remove the marketplace registration \u2014 ` + failDetail(`claude plugin marketplace remove ${MARKETPLACE_NAME}`, remove),
+        stagingRoot
+      )
+    ];
+  }
+  return [
+    {
+      platform: PLATFORM,
+      action: "remove",
+      path: stagingRoot,
+      detail: `removed marketplace registration "${MARKETPLACE_NAME}" (no plugins remain)`
+    }
+  ];
+}
+async function claudeDriveUpdate(connectorId, stagingRoot, pluginDir) {
+  const pluginKey = claudePluginKey(connectorId);
+  const bin = claudeBinary();
+  if (!bin) {
+    return {
+      changes: [
+        warn(
+          `claude CLI not found on PATH \u2014 bundle re-staged but the installed copy was not updated. Run manually: claude plugin update ${pluginKey}`,
+          stagingRoot
+        )
+      ],
+      installed: false
+    };
+  }
+  if (!claudePluginInstalled(connectorId)) {
+    return claudeDriveInstall(connectorId, stagingRoot, pluginDir);
+  }
+  const update = await runHostCommand(bin, ["plugin", "update", pluginKey]);
+  if (update.ok) {
+    return {
+      changes: [
+        {
+          platform: PLATFORM,
+          action: "update",
+          detail: `updated plugin ${pluginKey} (claude plugin update)`
+        }
+      ],
+      installed: true
+    };
+  }
+  const changes = [
+    warn(
+      `\`claude plugin update\` did not complete (` + failDetail("update", update) + `) \u2014 falling back to uninstall + install`
+    )
+  ];
+  const un = await claudeDriveUninstall(connectorId);
+  changes.push(...un.changes);
+  if (!un.removed) return { changes, installed: claudePluginInstalled(connectorId) };
+  const re = await claudeDriveInstall(connectorId, stagingRoot, pluginDir);
+  changes.push(...re.changes);
+  return { changes, installed: re.installed };
+}
+function errMessage2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function stagedClaudePlugins(stagingRoot) {
+  if (!existsSync3(stagingRoot)) return [];
+  try {
+    return readdirSync2(stagingRoot).filter(
+      (name) => existsSync3(join3(stagingRoot, name, ".claude-plugin", "plugin.json"))
+    ).sort();
+  } catch {
+    return [];
+  }
+}
+function regenerateClaudeCatalog(stagingRoot, changes) {
+  const catalogPath = join3(stagingRoot, ".claude-plugin", "marketplace.json");
+  const plugins = stagedClaudePlugins(stagingRoot).map((name) => {
+    let description = `${name} \u2014 connector emitted by agent-connector`;
+    try {
+      const manifest = JSON.parse(
+        readFileSync(join3(stagingRoot, name, ".claude-plugin", "plugin.json"), "utf8")
+      );
+      if (typeof manifest.description === "string") description = manifest.description;
+    } catch {
+    }
+    return { name, source: `./${name}`, description };
+  });
+  const catalog = {
+    name: MARKETPLACE_NAME,
+    owner: { name: MARKETPLACE_NAME },
+    plugins
+  };
+  const serialized = `${JSON.stringify(catalog, null, 2)}
+`;
+  let existing = null;
+  try {
+    existing = readFileSync(catalogPath, "utf8");
+  } catch {
+  }
+  if (existing === serialized) return;
+  ensureDir(dirname2(catalogPath));
+  writeFileSync(catalogPath, serialized, "utf8");
+  changes.push({
+    platform: PLATFORM,
+    action: existing == null ? "create" : "update",
+    path: catalogPath,
+    detail: `regenerated shared marketplace catalog (${plugins.length} plugin(s))`
+  });
+}
+function stageClaudeBundle(connector, changes) {
+  const stagingRoot = claudeStagingRoot();
+  const pluginDir = join3(stagingRoot, connector.id);
+  const existed = existsSync3(pluginDir);
+  const result = packageConnector(connector, {
+    outDir: stagingRoot,
+    format: "claude-plugin"
+  });
+  changes.push({
+    platform: PLATFORM,
+    action: existed ? "update" : "create",
+    path: pluginDir,
+    detail: `staged marketplace bundle (${result.files.length} files, claude-plugin)`
+  });
+  regenerateClaudeCatalog(stagingRoot, changes);
+  return { pluginDir, contentHash: hashDirectory(pluginDir) };
+}
+var claudeDriver = {
+  platform: PLATFORM,
+  format: "claude-plugin",
+  binary: claudeBinary,
+  stagingRoot: claudeStagingRoot,
+  pluginDir(id) {
+    return join3(claudeStagingRoot(), id);
+  },
+  installed: claudePluginInstalled,
+  stage(connector, changes) {
+    return stageClaudeBundle(connector, changes).contentHash;
+  },
+  planInstall(connector, changes) {
+    const stagingRoot = claudeStagingRoot();
+    const registeredAt = claudeKnownMarketplacePath(MARKETPLACE_NAME);
+    changes.push({
+      platform: PLATFORM,
+      action: registeredAt === stagingRoot ? "skip" : "create",
+      path: stagingRoot,
+      detail: registeredAt === stagingRoot ? `marketplace "${MARKETPLACE_NAME}" already registered` : `run: claude plugin marketplace add ${stagingRoot}`
+    });
+    changes.push({
+      platform: PLATFORM,
+      action: claudePluginInstalled(connector.id) ? "skip" : "create",
+      detail: claudePluginInstalled(connector.id) ? `plugin ${claudePluginKey(connector.id)} already installed` : `run: claude plugin install ${claudePluginKey(connector.id)}`
+    });
+  },
+  planUninstall(id, changes) {
+    const stagingRoot = claudeStagingRoot();
+    const pluginDir = join3(stagingRoot, id);
+    const pluginKey = claudePluginKey(id);
+    changes.push({
+      platform: PLATFORM,
+      action: claudePluginInstalled(id) ? "remove" : "skip",
+      detail: claudePluginInstalled(id) ? `run: claude plugin uninstall ${pluginKey}` : `plugin ${pluginKey} not installed on claude-code`
+    });
+    if (existsSync3(pluginDir)) {
+      changes.push({
+        platform: PLATFORM,
+        action: "remove",
+        path: pluginDir,
+        detail: "remove staged marketplace bundle"
+      });
+    }
+    const othersStaged = stagedClaudePlugins(stagingRoot).some((n) => n !== id);
+    if (!othersStaged && claudeKnownMarketplacePath(MARKETPLACE_NAME) === stagingRoot) {
+      changes.push({
+        platform: PLATFORM,
+        action: "remove",
+        path: stagingRoot,
+        detail: `run: claude plugin marketplace remove ${MARKETPLACE_NAME} (when no plugins remain)`
+      });
+    }
+  },
+  async driveInstall(id) {
+    const stagingRoot = claudeStagingRoot();
+    const out = await claudeDriveInstall(id, stagingRoot, join3(stagingRoot, id));
+    return { changes: out.changes, ok: out.installed };
+  },
+  async driveUninstall(id) {
+    const out = await claudeDriveUninstall(id);
+    return { changes: out.changes, ok: out.removed };
+  },
+  async driveUpdate(id) {
+    const stagingRoot = claudeStagingRoot();
+    const out = await claudeDriveUpdate(id, stagingRoot, join3(stagingRoot, id));
+    return { changes: out.changes, ok: out.installed };
+  },
+  async finishUninstall(id, changes) {
+    const stagingRoot = claudeStagingRoot();
+    const pluginDir = join3(stagingRoot, id);
+    if (existsSync3(pluginDir)) {
+      try {
+        rmSync2(pluginDir, { recursive: true, force: true });
+        changes.push({
+          platform: PLATFORM,
+          action: "remove",
+          path: pluginDir,
+          detail: "removed staged marketplace bundle"
+        });
+      } catch (err) {
+        changes.push({
+          platform: PLATFORM,
+          action: "warn",
+          path: pluginDir,
+          detail: `could not remove staged bundle: ${errMessage2(err)}`
+        });
+      }
+    }
+    if (existsSync3(stagingRoot)) regenerateClaudeCatalog(stagingRoot, changes);
+    const nothingStaged = stagedClaudePlugins(stagingRoot).length === 0;
+    if (nothingStaged && !anyClaudeAgentConnectorPlugins() && claudeKnownMarketplacePath(MARKETPLACE_NAME) === stagingRoot) {
+      changes.push(...await claudeDriveMarketplaceRemove(stagingRoot));
+    }
+  }
+};
+
+// src/core/marketplace-drivers/codex.ts
+import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync2, rmSync as rmSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname3, join as join4 } from "path";
+var PLATFORM2 = "codex";
+function codexBinary() {
+  return findOnPath("codex");
+}
+function codexManualInstallCommands(connectorId, stagingRoot) {
+  return `codex plugin marketplace add ${stagingRoot} && codex plugin add ${codexPluginKey(connectorId)}`;
+}
+function errMessage3(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function warn2(detail, path) {
+  return { platform: PLATFORM2, action: "warn", detail, ...path ? { path } : {} };
+}
+function failDetail2(step, r) {
+  if (r.timedOut) return `${step} timed out`;
+  if (r.error) return `${step} failed to spawn: ${r.error}`;
+  const line = firstLine(r.stderr) || firstLine(r.stdout);
+  return `${step} exited ${r.code}${line ? `: ${line}` : ""}`;
+}
+function stagedCodexPlugins(stagingRoot) {
+  if (!existsSync4(stagingRoot)) return [];
+  try {
+    return readdirSync3(stagingRoot).filter(
+      (name) => existsSync4(join4(stagingRoot, name, ".codex-plugin", "plugin.json"))
+    ).sort();
+  } catch {
+    return [];
+  }
+}
+function codexCatalogPath(stagingRoot) {
+  return join4(stagingRoot, ".agents", "plugins", "marketplace.json");
+}
+function regenerateCodexCatalog(stagingRoot, changes) {
+  const catalogPath = codexCatalogPath(stagingRoot);
+  const plugins = stagedCodexPlugins(stagingRoot).map((name) => {
+    let description = `${name} \u2014 connector emitted by agent-connector`;
+    try {
+      const manifest = JSON.parse(
+        readFileSync2(join4(stagingRoot, name, ".codex-plugin", "plugin.json"), "utf8")
+      );
+      if (typeof manifest.description === "string") description = manifest.description;
+    } catch {
+    }
+    return { name, source: `./${name}`, description };
+  });
+  const catalog = { name: MARKETPLACE_NAME, owner: { name: MARKETPLACE_NAME }, plugins };
+  const serialized = `${JSON.stringify(catalog, null, 2)}
+`;
+  let existing = null;
+  try {
+    existing = readFileSync2(catalogPath, "utf8");
+  } catch {
+  }
+  if (existing === serialized) return;
+  ensureDir(dirname3(catalogPath));
+  writeFileSync2(catalogPath, serialized, "utf8");
+  changes.push({
+    platform: PLATFORM2,
+    action: existing == null ? "create" : "update",
+    path: catalogPath,
+    detail: `regenerated shared marketplace catalog (${plugins.length} plugin(s))`
+  });
+}
+function stageCodexBundle(connector, changes) {
+  const stagingRoot = codexStagingRoot();
+  const pluginDir = join4(stagingRoot, connector.id);
+  const existed = existsSync4(pluginDir);
+  const result = packageConnector(connector, { outDir: stagingRoot, format: "codex-plugin" });
+  changes.push({
+    platform: PLATFORM2,
+    action: existed ? "update" : "create",
+    path: pluginDir,
+    detail: `staged marketplace bundle (${result.files.length} files, codex-plugin)`
+  });
+  regenerateCodexCatalog(stagingRoot, changes);
+  return { pluginDir, contentHash: hashDirectory(pluginDir) };
+}
+async function driveInstall(connectorId) {
+  const stagingRoot = codexStagingRoot();
+  const changes = [];
+  const pluginKey = codexPluginKey(connectorId);
+  const bin = codexBinary();
+  if (!bin) {
+    changes.push(
+      warn2(
+        `codex CLI not found on PATH \u2014 bundle staged but not installed. Install manually: ${codexManualInstallCommands(connectorId, stagingRoot)}`,
+        stagingRoot
+      )
+    );
+    return { changes, ok: false };
+  }
+  const registeredAt = codexMarketplaceSource(MARKETPLACE_NAME);
+  if (samePath(registeredAt, stagingRoot)) {
+    changes.push({
+      platform: PLATFORM2,
+      action: "skip",
+      path: stagingRoot,
+      detail: `marketplace "${MARKETPLACE_NAME}" already registered`
+    });
+  } else if (registeredAt != null) {
+    changes.push(
+      warn2(
+        `a marketplace named "${MARKETPLACE_NAME}" is already registered at ${registeredAt} (not ours) \u2014 refusing to touch it. Remove it first (codex plugin marketplace remove ${MARKETPLACE_NAME}) or install manually: ` + codexManualInstallCommands(connectorId, stagingRoot)
+      )
+    );
+    return { changes, ok: false };
+  } else {
+    const add2 = await runHostCommand(bin, ["plugin", "marketplace", "add", stagingRoot]);
+    if (!samePath(codexMarketplaceSource(MARKETPLACE_NAME), stagingRoot)) {
+      changes.push(
+        warn2(
+          `could not register the local marketplace \u2014 ` + failDetail2("codex plugin marketplace add", add2) + `. Install manually: ${codexManualInstallCommands(connectorId, stagingRoot)}`,
+          stagingRoot
+        )
+      );
+      return { changes, ok: false };
+    }
+    changes.push({
+      platform: PLATFORM2,
+      action: "create",
+      path: stagingRoot,
+      detail: `registered local marketplace "${MARKETPLACE_NAME}" (codex plugin marketplace add)`
+    });
+  }
+  if (codexPluginInstalled(connectorId)) {
+    changes.push({
+      platform: PLATFORM2,
+      action: "skip",
+      detail: `plugin ${pluginKey} already installed`
+    });
+    return { changes, ok: true };
+  }
+  const add = await runHostCommand(bin, ["plugin", "add", pluginKey]);
+  if (!add.ok || !codexPluginInstalled(connectorId)) {
+    changes.push(
+      warn2(`plugin add did not complete \u2014 ` + failDetail2(`codex plugin add ${pluginKey}`, add))
+    );
+    return { changes, ok: false };
+  }
+  changes.push({
+    platform: PLATFORM2,
+    action: "create",
+    detail: `installed plugin ${pluginKey} (scope user)`
+  });
+  return { changes, ok: true };
+}
+async function driveUninstall(connectorId) {
+  const changes = [];
+  const pluginKey = codexPluginKey(connectorId);
+  if (!codexPluginInstalled(connectorId)) {
+    changes.push({
+      platform: PLATFORM2,
+      action: "skip",
+      detail: `plugin ${pluginKey} not installed on codex`
+    });
+    return { changes, ok: true };
+  }
+  const bin = codexBinary();
+  if (!bin) {
+    changes.push(
+      warn2(
+        `codex CLI not found on PATH \u2014 cannot drive the uninstall. Run manually: codex plugin remove ${pluginKey}`
+      )
+    );
+    return { changes, ok: false };
+  }
+  const remove = await runHostCommand(bin, ["plugin", "remove", pluginKey]);
+  if (!remove.ok || codexPluginInstalled(connectorId)) {
+    changes.push(
+      warn2(`plugin remove did not complete \u2014 ` + failDetail2(`codex plugin remove ${pluginKey}`, remove))
+    );
+    return { changes, ok: false };
+  }
+  changes.push({
+    platform: PLATFORM2,
+    action: "remove",
+    detail: `uninstalled plugin ${pluginKey} (codex plugin remove)`
+  });
+  return { changes, ok: true };
+}
+async function driveMarketplaceRemove(stagingRoot) {
+  const bin = codexBinary();
+  if (!bin) {
+    return [
+      warn2(
+        `codex CLI not found on PATH \u2014 marketplace registration "${MARKETPLACE_NAME}" left behind. Run manually: codex plugin marketplace remove ${MARKETPLACE_NAME}`,
+        stagingRoot
+      )
+    ];
+  }
+  const remove = await runHostCommand(bin, ["plugin", "marketplace", "remove", MARKETPLACE_NAME]);
+  if (!remove.ok && codexMarketplaceSource(MARKETPLACE_NAME) != null) {
+    return [
+      warn2(
+        `could not remove the marketplace registration \u2014 ` + failDetail2(`codex plugin marketplace remove ${MARKETPLACE_NAME}`, remove),
+        stagingRoot
+      )
+    ];
+  }
+  return [
+    {
+      platform: PLATFORM2,
+      action: "remove",
+      path: stagingRoot,
+      detail: `removed marketplace registration "${MARKETPLACE_NAME}" (no plugins remain)`
+    }
+  ];
+}
+var codexDriver = {
+  platform: PLATFORM2,
+  format: "codex-plugin",
+  binary: codexBinary,
+  stagingRoot: codexStagingRoot,
+  pluginDir(id) {
+    return join4(codexStagingRoot(), id);
+  },
+  installed: codexPluginInstalled,
+  stage(connector, changes) {
+    return stageCodexBundle(connector, changes).contentHash;
+  },
+  planInstall(connector, changes) {
+    const stagingRoot = codexStagingRoot();
+    const registered = samePath(codexMarketplaceSource(MARKETPLACE_NAME), stagingRoot);
+    changes.push({
+      platform: PLATFORM2,
+      action: registered ? "skip" : "create",
+      path: stagingRoot,
+      detail: registered ? `marketplace "${MARKETPLACE_NAME}" already registered` : `run: codex plugin marketplace add ${stagingRoot}`
+    });
+    changes.push({
+      platform: PLATFORM2,
+      action: codexPluginInstalled(connector.id) ? "skip" : "create",
+      detail: codexPluginInstalled(connector.id) ? `plugin ${codexPluginKey(connector.id)} already installed` : `run: codex plugin add ${codexPluginKey(connector.id)}`
+    });
+  },
+  planUninstall(id, changes) {
+    const stagingRoot = codexStagingRoot();
+    const pluginDir = join4(stagingRoot, id);
+    const pluginKey = codexPluginKey(id);
+    changes.push({
+      platform: PLATFORM2,
+      action: codexPluginInstalled(id) ? "remove" : "skip",
+      detail: codexPluginInstalled(id) ? `run: codex plugin remove ${pluginKey}` : `plugin ${pluginKey} not installed on codex`
+    });
+    if (existsSync4(pluginDir)) {
+      changes.push({
+        platform: PLATFORM2,
+        action: "remove",
+        path: pluginDir,
+        detail: "remove staged marketplace bundle"
+      });
+    }
+    const othersStaged = stagedCodexPlugins(stagingRoot).some((n) => n !== id);
+    if (!othersStaged && samePath(codexMarketplaceSource(MARKETPLACE_NAME), stagingRoot)) {
+      changes.push({
+        platform: PLATFORM2,
+        action: "remove",
+        path: stagingRoot,
+        detail: `run: codex plugin marketplace remove ${MARKETPLACE_NAME} (when no plugins remain)`
+      });
+    }
+  },
+  driveInstall,
+  driveUninstall,
+  // Codex has no `plugin update` verb — update IS re-stage (done by the caller)
+  // + `plugin add`, which is idempotent and version-cached.
+  async driveUpdate(id) {
+    return driveInstall(id);
+  },
+  async finishUninstall(id, changes) {
+    const stagingRoot = codexStagingRoot();
+    const pluginDir = join4(stagingRoot, id);
+    if (existsSync4(pluginDir)) {
+      try {
+        rmSync3(pluginDir, { recursive: true, force: true });
+        changes.push({
+          platform: PLATFORM2,
+          action: "remove",
+          path: pluginDir,
+          detail: "removed staged marketplace bundle"
+        });
+      } catch (err) {
+        changes.push({
+          platform: PLATFORM2,
+          action: "warn",
+          path: pluginDir,
+          detail: `could not remove staged bundle: ${errMessage3(err)}`
+        });
+      }
+    }
+    if (existsSync4(stagingRoot)) regenerateCodexCatalog(stagingRoot, changes);
+    const nothingStaged = stagedCodexPlugins(stagingRoot).length === 0;
+    if (nothingStaged && !anyCodexAgentConnectorPlugins() && samePath(codexMarketplaceSource(MARKETPLACE_NAME), stagingRoot)) {
+      changes.push(...await driveMarketplaceRemove(stagingRoot));
+    }
+  }
+};
+
+// src/core/marketplace-drivers/agy.ts
+import { existsSync as existsSync5, rmSync as rmSync4 } from "fs";
+import { join as join5 } from "path";
+function agyBinary() {
+  return findOnPath("agy");
+}
+function errMessage4(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function failDetail3(step, r) {
+  if (r.timedOut) return `${step} timed out`;
+  if (r.error) return `${step} failed to spawn: ${r.error}`;
+  const line = firstLine(r.stderr) || firstLine(r.stdout);
+  return `${step} exited ${r.code}${line ? `: ${line}` : ""}`;
+}
+function stageAgyBundle(connector, platform, changes) {
+  const stagingRoot = agyStagingRoot();
+  const pluginDir = join5(stagingRoot, connector.id);
+  const existed = existsSync5(pluginDir);
+  const result = packageConnector(connector, { outDir: stagingRoot, format: "agy-plugin" });
+  changes.push({
+    platform,
+    action: existed ? "update" : "create",
+    path: pluginDir,
+    detail: `staged marketplace bundle (${result.files.length} files, agy-plugin)`
+  });
+  return { pluginDir, contentHash: hashDirectory(pluginDir) };
+}
+function makeAgyDriver(platform) {
+  const warn3 = (detail, path) => ({
+    platform,
+    action: "warn",
+    detail,
+    ...path ? { path } : {}
+  });
+  const manualInstall = (pluginDir) => `agy plugin install ${pluginDir}`;
+  return {
+    platform,
+    format: "agy-plugin",
+    binary: agyBinary,
+    stagingRoot: agyStagingRoot,
+    pluginDir(id) {
+      return join5(agyStagingRoot(), id);
+    },
+    installed: agyPluginInstalled,
+    stage(connector, changes) {
+      return stageAgyBundle(connector, platform, changes).contentHash;
+    },
+    planInstall(connector, changes) {
+      const pluginDir = join5(agyStagingRoot(), connector.id);
+      changes.push({
+        platform,
+        action: agyPluginInstalled(connector.id) ? "skip" : "create",
+        detail: agyPluginInstalled(connector.id) ? `plugin ${connector.id} already installed` : `run: agy plugin install ${pluginDir}`
+      });
+    },
+    planUninstall(id, changes) {
+      const pluginDir = join5(agyStagingRoot(), id);
+      changes.push({
+        platform,
+        action: agyPluginInstalled(id) ? "remove" : "skip",
+        detail: agyPluginInstalled(id) ? `run: agy plugin uninstall ${id}` : `plugin ${id} not installed on ${platform}`
+      });
+      if (existsSync5(pluginDir)) {
+        changes.push({
+          platform,
+          action: "remove",
+          path: pluginDir,
+          detail: "remove staged marketplace bundle"
+        });
+      }
+    },
+    async driveInstall(id) {
+      const changes = [];
+      const pluginDir = join5(agyStagingRoot(), id);
+      const bin = agyBinary();
+      if (!bin) {
+        changes.push(
+          warn3(
+            `agy CLI not found on PATH \u2014 bundle staged but not installed. Install manually: ${manualInstall(pluginDir)}`,
+            pluginDir
+          )
+        );
+        return { changes, ok: false };
+      }
+      if (agyPluginInstalled(id)) {
+        changes.push({
+          platform,
+          action: "skip",
+          detail: `plugin ${id} already installed`
+        });
+        return { changes, ok: true };
+      }
+      await runHostCommand(bin, ["plugin", "validate", pluginDir]);
+      const install = await runHostCommand(bin, ["plugin", "install", pluginDir]);
+      if (!install.ok || !agyPluginInstalled(id)) {
+        changes.push(
+          warn3(`plugin install did not complete \u2014 ` + failDetail3(`agy plugin install ${pluginDir}`, install))
+        );
+        return { changes, ok: false };
+      }
+      changes.push({
+        platform,
+        action: "create",
+        detail: `installed plugin ${id} (scope user)`
+      });
+      return { changes, ok: true };
+    },
+    async driveUninstall(id) {
+      const changes = [];
+      if (!agyPluginInstalled(id)) {
+        changes.push({
+          platform,
+          action: "skip",
+          detail: `plugin ${id} not installed on ${platform}`
+        });
+        return { changes, ok: true };
+      }
+      const bin = agyBinary();
+      if (!bin) {
+        changes.push(
+          warn3(
+            `agy CLI not found on PATH \u2014 cannot drive the uninstall. Run manually: agy plugin uninstall ${id}`
+          )
+        );
+        return { changes, ok: false };
+      }
+      const uninstall = await runHostCommand(bin, ["plugin", "uninstall", id]);
+      if (!uninstall.ok || agyPluginInstalled(id)) {
+        changes.push(
+          warn3(`plugin uninstall did not complete \u2014 ` + failDetail3(`agy plugin uninstall ${id}`, uninstall))
+        );
+        return { changes, ok: false };
+      }
+      changes.push({
+        platform,
+        action: "remove",
+        detail: `uninstalled plugin ${id} (agy plugin uninstall)`
+      });
+      return { changes, ok: true };
+    },
+    // No `plugin update` verb — update = re-stage (done by the caller) +
+    // `plugin install` (idempotent overwrite). Force a fresh install even when
+    // the probe already shows it present (the bundle on disk changed).
+    async driveUpdate(id) {
+      const changes = [];
+      const pluginDir = join5(agyStagingRoot(), id);
+      const bin = agyBinary();
+      if (!bin) {
+        changes.push(
+          warn3(
+            `agy CLI not found on PATH \u2014 bundle re-staged but the installed copy was not updated. Run manually: ${manualInstall(pluginDir)}`,
+            pluginDir
+          )
+        );
+        return { changes, ok: false };
+      }
+      const install = await runHostCommand(bin, ["plugin", "install", pluginDir]);
+      if (!install.ok || !agyPluginInstalled(id)) {
+        changes.push(
+          warn3(`plugin install did not complete \u2014 ` + failDetail3(`agy plugin install ${pluginDir}`, install))
+        );
+        return { changes, ok: false };
+      }
+      changes.push({
+        platform,
+        action: "update",
+        detail: `updated plugin ${id} (agy plugin install \u2014 idempotent overwrite)`
+      });
+      return { changes, ok: true };
+    },
+    // Direct driver: no catalog, no marketplace de-registration. Cleanup is just
+    // removing the staged bundle dir (the host copied it into its own store).
+    async finishUninstall(id, changes) {
+      const pluginDir = join5(agyStagingRoot(), id);
+      if (existsSync5(pluginDir)) {
+        try {
+          rmSync4(pluginDir, { recursive: true, force: true });
+          changes.push({
+            platform,
+            action: "remove",
+            path: pluginDir,
+            detail: "removed staged marketplace bundle"
+          });
+        } catch (err) {
+          changes.push({
+            platform,
+            action: "warn",
+            path: pluginDir,
+            detail: `could not remove staged bundle: ${errMessage4(err)}`
+          });
+        }
+      }
+    }
+  };
+}
+
+// src/core/marketplace-drivers/registry.ts
+var agyDrivers = /* @__PURE__ */ new Map();
+function agyDriver(platform) {
+  let driver = agyDrivers.get(platform);
+  if (!driver) {
+    driver = makeAgyDriver(platform);
+    agyDrivers.set(platform, driver);
+  }
+  return driver;
+}
+function getMarketplaceDriver(platform) {
+  switch (platform) {
+    case "claude-code":
+      return claudeDriver;
+    case "codex":
+      return codexDriver;
+    case "antigravity":
+    case "antigravity-cli":
+      return agyDriver(platform);
+    default:
+      return null;
+  }
+}
+
+// src/core/marketplace.ts
+function parseInstallMethod(value) {
+  if (value == null || value === "direct" || value === "marketplace") {
+    return value ?? "direct";
+  }
+  return null;
+}
+function parseUninstallMethod(value) {
+  if (value == null || value === "auto" || value === "direct" || value === "marketplace") {
+    return value ?? "auto";
+  }
+  return null;
+}
+var MARKETPLACE_FORMAT_BY_PLATFORM = {
+  "claude-code": "claude-plugin",
+  codex: "codex-plugin",
+  droid: "factory-plugin",
+  "gemini-cli": "gemini-extension",
+  "qwen-code": "qwen-extension",
+  antigravity: "agy-plugin",
+  "antigravity-cli": "agy-plugin",
+  cursor: "cursor-plugin",
+  kimi: "kimi-plugin",
+  opencode: "npm-plugin",
+  kilo: "npm-plugin",
+  "kilo-cli": "npm-plugin",
+  pi: "npm-plugin",
+  "vscode-copilot": "claude-plugin",
+  openclaw: "claude-plugin",
+  omp: "claude-plugin"
+};
+var DRIVABLE_MARKETPLACE_PLATFORMS = /* @__PURE__ */ new Set([
+  "claude-code",
+  "codex",
+  "antigravity",
+  "antigravity-cli"
+]);
+function newResult2(connectorId, dryRun) {
+  return { connectorId, dryRun, changes: [], warnings: [] };
+}
+function errMessage5(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function manualHint(platform, format, id) {
+  const steps = installInstructions(format, id, "<out-dir>").join("; ");
+  return `agent-connector cannot drive the ${platform} marketplace flow yet \u2014 install manually: \`agent-connector package --format ${format} --out <out-dir>\` then: ${steps}`;
+}
+async function directInstallPresent(connector, platform, scope, projectDir) {
+  try {
+    const adapter = await loadAdapter(platform);
+    if (!adapter) return false;
+    const ctx = {
+      connector,
+      scope: connector.platforms[platform]?.scope ?? scope,
+      projectDir,
+      homeBinPath: homeBinPath(),
+      dataRoot: dataRoot(),
+      dryRun: true
+    };
+    const escaped = connector.id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const serverKey = new RegExp(`"${escaped}"\\s*:|\\.${escaped}\\]`);
+    const hookCommand = new RegExp(`--connector\\s+${escaped}(?![\\w-])`);
+    const matches = (path, re) => {
+      try {
+        return re.test(readFileSync3(path, "utf8"));
+      } catch {
+        return false;
+      }
+    };
+    try {
+      if (matches(adapter.getServerConfigPath(ctx), serverKey)) return true;
+    } catch {
+    }
+    try {
+      if (matches(adapter.getHookConfigPath(ctx), hookCommand)) return true;
+    } catch {
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function installViaMarketplace(opts) {
+  const { connector, modulePath, scope, projectDir, dryRun } = opts;
+  const result = newResult2(connector.id, dryRun);
+  if (scope !== "user") {
+    result.warnings.push(
+      "--method marketplace supports --scope user only in this version (project-scope plugin installs are deferred)"
+    );
+    return result;
+  }
+  if (!dryRun) {
+    try {
+      ensureHomeBin(resolveCliEntry());
+    } catch (err) {
+      log.warn(`ensureHomeBin failed: ${errMessage5(err)}`);
+    }
+    try {
+      registerConnector(connector, modulePath);
+    } catch (err) {
+      log.warn(`registerConnector failed: ${errMessage5(err)}`);
+    }
+  }
+  const explicit = opts.targets != null && opts.targets.length > 0;
+  const targets = await resolveTargets(opts.targets, connector.targets, projectDir);
+  if (targets.length === 0) {
+    result.warnings.push(
+      "no target platforms resolved (none installed / detected, or all filtered out)"
+    );
+    return result;
+  }
+  for (const id of targets) {
+    const format = MARKETPLACE_FORMAT_BY_PLATFORM[id];
+    if (!format) {
+      result.changes.push({
+        platform: id,
+        action: explicit ? "warn" : "skip",
+        detail: `no marketplace/plugin distribution path exists for ${id} \u2014 use the direct method: \`agent-connector install --targets ${id}\``
+      });
+      continue;
+    }
+    if (!DRIVABLE_MARKETPLACE_PLATFORMS.has(id)) {
+      result.changes.push({
+        platform: id,
+        action: explicit ? "warn" : "skip",
+        detail: manualHint(id, format, connector.id)
+      });
+      continue;
+    }
+    const driver = getMarketplaceDriver(id);
+    if (!driver) {
+      result.changes.push({
+        platform: id,
+        action: explicit ? "warn" : "skip",
+        detail: manualHint(id, format, connector.id)
+      });
+      continue;
+    }
+    if (await directInstallPresent(connector, id, scope, projectDir)) {
+      result.changes.push({
+        platform: id,
+        action: "warn",
+        detail: `"${connector.id}" is already installed DIRECTLY on ${id} \u2014 refusing the marketplace install (both at once duplicates hooks + the MCP server and corrupts telemetry). Run \`agent-connector uninstall --targets ${id}\` first, or keep the direct install.`
+      });
+      continue;
+    }
+    const pluginDir = driver.pluginDir(connector.id);
+    if (dryRun) {
+      const planned = packageConnector(connector, {
+        outDir: driver.stagingRoot(),
+        format,
+        dryRun: true
+      });
+      for (const file of planned.files) {
+        result.changes.push({
+          platform: id,
+          action: "create",
+          path: file,
+          detail: "stage bundle file"
+        });
+      }
+      driver.planInstall(connector, result.changes);
+      continue;
+    }
+    const contentHash = driver.stage(connector, result.changes);
+    const outcome = await driver.driveInstall(connector.id);
+    result.changes.push(...outcome.changes);
+    if (outcome.ok) {
+      const installs = readMarketplaceInstalls(connector.id);
+      const record = {
+        format,
+        bundleDir: pluginDir,
+        marketplace: MARKETPLACE_NAME,
+        scope,
+        version: connector.version,
+        contentHash,
+        installedAt: installs[id]?.installedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      };
+      installs[id] = record;
+      writeMarketplaceInstalls(connector.id, installs);
+    }
+  }
+  return result;
+}
+var MANUAL_UNINSTALL = {
+  "gemini-cli": (id) => `gemini extensions uninstall ${id}`,
+  antigravity: (id) => `agy plugin uninstall ${id}`,
+  "antigravity-cli": (id) => `agy plugin uninstall ${id}`,
+  codex: (id) => `codex plugin remove ${id}@${MARKETPLACE_NAME}`
+};
+async function uninstallViaMarketplace(opts) {
+  const { connectorId, dryRun, purge } = opts;
+  const result = newResult2(connectorId, dryRun);
+  let targets;
+  if (opts.targets && opts.targets.length > 0) {
+    targets = [...new Set(opts.targets)];
+  } else {
+    targets = Object.keys(readMarketplaceInstalls(connectorId));
+    for (const id of DRIVABLE_MARKETPLACE_PLATFORMS) {
+      if (targets.includes(id)) continue;
+      const driver = getMarketplaceDriver(id);
+      if (driver?.installed(connectorId)) targets = [...targets, id];
+    }
+  }
+  if (targets.length === 0) {
+    result.warnings.push(
+      `no marketplace installs found for "${connectorId}" (nothing recorded, no host evidence)`
+    );
+    return result;
+  }
+  for (const id of targets) {
+    const driver = getMarketplaceDriver(id);
+    if (!driver) {
+      const manual = MANUAL_UNINSTALL[id];
+      const recorded = readMarketplaceInstalls(connectorId)[id] != null;
+      result.changes.push({
+        platform: id,
+        action: recorded ? "warn" : "skip",
+        detail: recorded ? `agent-connector cannot drive the ${id} marketplace uninstall yet \u2014 run manually${manual ? `: ${manual(connectorId)}` : ""} (record kept until then)` : `no marketplace install recorded for ${id}`
+      });
+      continue;
+    }
+    if (dryRun) {
+      driver.planUninstall(connectorId, result.changes);
+      continue;
+    }
+    const outcome = await driver.driveUninstall(connectorId);
+    result.changes.push(...outcome.changes);
+    if (!outcome.ok) continue;
+    await driver.finishUninstall(connectorId, result.changes);
+    const installs = readMarketplaceInstalls(connectorId);
+    if (installs[id]) {
+      delete installs[id];
+      writeMarketplaceInstalls(connectorId, installs);
+      result.changes.push({
+        platform: id,
+        action: "remove",
+        path: marketplaceRoot(),
+        detail: "removed marketplace install record"
+      });
+    }
+  }
+  if (purge && !dryRun) {
+    const seenRoots = /* @__PURE__ */ new Set();
+    for (const id of DRIVABLE_MARKETPLACE_PLATFORMS) {
+      const driver = getMarketplaceDriver(id);
+      if (!driver) continue;
+      const root2 = driver.stagingRoot();
+      if (seenRoots.has(root2)) continue;
+      seenRoots.add(root2);
+      if (!existsSync6(root2)) continue;
+      let bundleDirs;
+      try {
+        bundleDirs = readdirSync4(root2).filter((n) => !n.startsWith("."));
+      } catch {
+        bundleDirs = [];
+      }
+      if (bundleDirs.length > 0) continue;
+      try {
+        rmSync5(root2, { recursive: true, force: true });
+        result.changes.push({
+          platform: id,
+          action: "remove",
+          path: root2,
+          detail: "removed empty marketplace staging root (--purge)"
+        });
+      } catch (err) {
+        log.warn(`marketplace staging-root removal failed: ${errMessage5(err)}`);
+      }
+    }
+    const root = marketplaceRoot();
+    try {
+      if (existsSync6(root) && readdirSync4(root).length === 0) {
+        rmSync5(root, { recursive: true, force: true });
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+async function upgradeViaMarketplace(opts) {
+  const { connector, scope, dryRun } = opts;
+  const result = newResult2(connector.id, dryRun);
+  if (scope !== "user") {
+    result.warnings.push(
+      "--method marketplace supports --scope user only in this version"
+    );
+    return result;
+  }
+  let targets;
+  if (opts.targets && opts.targets.length > 0) {
+    targets = [...new Set(opts.targets)];
+  } else {
+    targets = Object.keys(readMarketplaceInstalls(connector.id));
+    for (const id of DRIVABLE_MARKETPLACE_PLATFORMS) {
+      if (targets.includes(id)) continue;
+      const driver = getMarketplaceDriver(id);
+      if (driver?.installed(connector.id)) targets = [...targets, id];
+    }
+  }
+  if (targets.length === 0) {
+    result.warnings.push(
+      `no marketplace installs found for "${connector.id}" \u2014 run \`agent-connector install --method marketplace\` first`
+    );
+    return result;
+  }
+  for (const id of targets) {
+    const driver = getMarketplaceDriver(id);
+    if (!driver) {
+      result.changes.push({
+        platform: id,
+        action: "warn",
+        detail: `agent-connector cannot drive a ${id} marketplace upgrade yet \u2014 re-run \`agent-connector package\` and the host's own update flow`
+      });
+      continue;
+    }
+    const record = readMarketplaceInstalls(connector.id)[id];
+    if (!record && !driver.installed(connector.id)) {
+      result.changes.push({
+        platform: id,
+        action: "warn",
+        detail: `"${connector.id}" is not marketplace-installed on ${id} \u2014 run \`agent-connector install --method marketplace --targets ${id}\``
+      });
+      continue;
+    }
+    if (record && record.version === connector.version) {
+      result.changes.push({
+        platform: id,
+        action: "warn",
+        detail: `connector.version is unchanged since the recorded install (${record.version}) \u2014 ${id} caches a versioned copy, so bump connector.version for the update to take effect`
+      });
+    }
+    const pluginDir = driver.pluginDir(connector.id);
+    if (dryRun) {
+      result.changes.push({
+        platform: id,
+        action: "update",
+        path: pluginDir,
+        detail: "re-stage marketplace bundle in place"
+      });
+      result.changes.push({
+        platform: id,
+        action: "update",
+        detail: `drive the ${id} host update flow`
+      });
+      continue;
+    }
+    const contentHash = driver.stage(connector, result.changes);
+    const outcome = await driver.driveUpdate(connector.id);
+    result.changes.push(...outcome.changes);
+    if (outcome.ok) {
+      const installs = readMarketplaceInstalls(connector.id);
+      installs[id] = {
+        format: record?.format ?? driver.format,
+        bundleDir: pluginDir,
+        marketplace: MARKETPLACE_NAME,
+        scope,
+        version: connector.version,
+        contentHash,
+        installedAt: record?.installedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      };
+      writeMarketplaceInstalls(connector.id, installs);
+    }
+  }
+  return result;
+}
+async function marketplaceDoctorChecks(connector, scope, projectDir) {
+  const groups = [];
+  const claude = await claudeMarketplaceGroup(connector, scope, projectDir);
+  if (claude) groups.push(claude);
+  const seenHosts = /* @__PURE__ */ new Set();
+  const candidates = ["codex", "antigravity", "antigravity-cli"].sort((a, b) => recordRank(connector.id, a) - recordRank(connector.id, b));
+  for (const platform of candidates) {
+    const driver = getMarketplaceDriver(platform);
+    if (!driver) continue;
+    const hostKey = driver.stagingRoot();
+    if (seenHosts.has(hostKey)) continue;
+    const group = await genericMarketplaceGroup(connector, platform, scope, projectDir);
+    if (group) {
+      groups.push(group);
+      seenHosts.add(hostKey);
+    }
+  }
+  groups.sort((a, b) => platformDoctorRank(a.platform) - platformDoctorRank(b.platform));
+  return groups;
+}
+function recordRank(connectorId, platform) {
+  return readMarketplaceInstalls(connectorId)[platform] ? 0 : 1;
+}
+function platformDoctorRank(platform) {
+  const order = ["claude-code", "codex", "antigravity", "antigravity-cli"];
+  const i = order.indexOf(platform);
+  return i === -1 ? order.length : i;
+}
+async function claudeMarketplaceGroup(connector, scope, projectDir) {
+  const id = connector.id;
+  const record = readMarketplaceInstalls(id)["claude-code"];
+  const pluginPresent = claudePluginInstalled(id);
+  if (!record && !pluginPresent) return null;
+  const results = [];
+  const stagingRoot = claudeStagingRoot();
+  const pluginKey = claudePluginKey(id);
+  const direct = await directInstallPresent(connector, "claude-code", scope, projectDir);
+  if (direct && pluginPresent) {
+    results.push({
+      check: `${id}: marketplace duplicate-registration`,
+      status: "fail",
+      message: `installed BOTH directly and as plugin ${pluginKey} \u2014 hooks + MCP server are duplicated`,
+      fix: `uninstall one method: \`agent-connector uninstall --method marketplace --targets claude-code\` or \`agent-connector uninstall --targets claude-code\``
+    });
+  }
+  if (record) {
+    const registeredAt = claudeKnownMarketplacePath(MARKETPLACE_NAME);
+    const catalogPath = join6(stagingRoot, ".claude-plugin", "marketplace.json");
+    let catalogListed = false;
+    try {
+      const catalog = JSON.parse(readFileSync3(catalogPath, "utf8"));
+      catalogListed = (catalog.plugins ?? []).some((p) => p.name === id);
+    } catch {
+      catalogListed = false;
+    }
+    const intact = registeredAt === stagingRoot && existsSync6(record.bundleDir) && catalogListed;
+    results.push({
+      check: `${id}: marketplace registration`,
+      status: intact ? "pass" : "fail",
+      message: intact ? `local marketplace "${MARKETPLACE_NAME}" registered at ${stagingRoot}, bundle staged + cataloged` : `marketplace registration broken (registered at ${registeredAt ?? "nowhere"}, bundle ${existsSync6(record.bundleDir) ? "present" : "missing"}, catalog ${catalogListed ? "lists it" : "does not list it"})`,
+      ...intact ? {} : { fix: `agent-connector install --method marketplace --targets claude-code` }
+    });
+  }
+  if (record && !pluginPresent) {
+    results.push({
+      check: `${id}: marketplace state drift`,
+      status: "warn",
+      message: `recorded as marketplace-installed but Claude's state shows ${pluginKey} absent`,
+      fix: `re-run \`agent-connector install --method marketplace --targets claude-code\` or \`agent-connector uninstall --method marketplace --targets claude-code\` to reconcile`
+    });
+  } else if (!record && pluginPresent) {
+    results.push({
+      check: `${id}: marketplace state drift`,
+      status: "warn",
+      message: `Claude lists ${pluginKey} installed but agent-connector has no record of it (manual install?)`,
+      fix: `adopt it: \`agent-connector install --method marketplace --targets claude-code\` (idempotent), or remove it: \`claude plugin uninstall ${pluginKey}\``
+    });
+  }
+  if (record) {
+    if (connector.version !== "0.0.0" && connector.version !== record.version) {
+      results.push({
+        check: `${id}: marketplace staleness`,
+        status: "warn",
+        message: `connector.version ${connector.version} \u2260 installed ${record.version}`,
+        fix: `agent-connector upgrade --method marketplace --targets claude-code`
+      });
+    } else if (existsSync6(record.bundleDir) && record.contentHash !== "" && hashDirectory(record.bundleDir) !== record.contentHash) {
+      results.push({
+        check: `${id}: marketplace staleness`,
+        status: "warn",
+        message: "staged bundle changed since install \u2014 Claude's cached copy is stale",
+        fix: `agent-connector upgrade --method marketplace --targets claude-code`
+      });
+    }
+  }
+  if (pluginPresent && !existsSync6(homeBinPath())) {
+    results.push({
+      check: `${id}: marketplace home-bin`,
+      status: "fail",
+      message: `installed plugin hooks exec ${homeBinPath()} which does not exist`,
+      fix: "agent-connector upgrade"
+    });
+  }
+  if (record && claudeBinary() == null) {
+    results.push({
+      check: `${id}: marketplace host binary`,
+      status: "warn",
+      message: "claude CLI not found on PATH \u2014 the recorded marketplace install cannot be managed until it is reinstalled"
+    });
+  }
+  if (results.every((r) => r.status === "pass")) {
+    results.push({
+      check: `${id}: marketplace install`,
+      status: "pass",
+      message: `${pluginKey} installed via marketplace (version ${record?.version ?? "unknown"})`
+    });
+  }
+  return { platform: "claude-code", results };
+}
+async function genericMarketplaceGroup(connector, platform, scope, projectDir) {
+  const driver = getMarketplaceDriver(platform);
+  if (!driver) return null;
+  const id = connector.id;
+  const record = readMarketplaceInstalls(id)[platform];
+  const installed = driver.installed(id);
+  if (!record && !installed) return null;
+  const results = [];
+  const direct = await directInstallPresent(connector, platform, scope, projectDir);
+  if (direct && installed) {
+    results.push({
+      check: `${id}: marketplace duplicate-registration`,
+      status: "fail",
+      message: `installed BOTH directly and as a marketplace plugin on ${platform} \u2014 hooks + MCP server are duplicated`,
+      fix: `uninstall one method: \`agent-connector uninstall --method marketplace --targets ${platform}\` or \`agent-connector uninstall --targets ${platform}\``
+    });
+  }
+  if (record && !installed) {
+    results.push({
+      check: `${id}: marketplace state drift`,
+      status: "warn",
+      message: `recorded as marketplace-installed but ${platform}'s state shows the plugin absent`,
+      fix: `re-run \`agent-connector install --method marketplace --targets ${platform}\` or \`agent-connector uninstall --method marketplace --targets ${platform}\` to reconcile`
+    });
+  } else if (!record && installed) {
+    results.push({
+      check: `${id}: marketplace state drift`,
+      status: "warn",
+      message: `${platform} lists the plugin installed but agent-connector has no record of it (manual install?)`,
+      fix: `adopt it: \`agent-connector install --method marketplace --targets ${platform}\` (idempotent), or remove it via the host's plugin uninstall`
+    });
+  }
+  if (record) {
+    if (connector.version !== "0.0.0" && connector.version !== record.version) {
+      results.push({
+        check: `${id}: marketplace staleness`,
+        status: "warn",
+        message: `connector.version ${connector.version} \u2260 installed ${record.version}`,
+        fix: `agent-connector upgrade --method marketplace --targets ${platform}`
+      });
+    } else if (existsSync6(record.bundleDir) && record.contentHash !== "" && hashDirectory(record.bundleDir) !== record.contentHash) {
+      results.push({
+        check: `${id}: marketplace staleness`,
+        status: "warn",
+        message: `staged bundle changed since install \u2014 ${platform}'s cached copy is stale`,
+        fix: `agent-connector upgrade --method marketplace --targets ${platform}`
+      });
+    }
+  }
+  if (installed && !existsSync6(homeBinPath())) {
+    results.push({
+      check: `${id}: marketplace home-bin`,
+      status: "fail",
+      message: `installed plugin hooks exec ${homeBinPath()} which does not exist`,
+      fix: "agent-connector upgrade"
+    });
+  }
+  if (record && driver.binary() == null) {
+    results.push({
+      check: `${id}: marketplace host binary`,
+      status: "warn",
+      message: `${platform} CLI not found on PATH \u2014 the recorded marketplace install cannot be managed until it is reinstalled`
+    });
+  }
+  if (results.every((r) => r.status === "pass")) {
+    results.push({
+      check: `${id}: marketplace install`,
+      status: "pass",
+      message: `${id} installed via marketplace on ${platform} (version ${record?.version ?? "unknown"})`
+    });
+  }
+  return { platform, results };
+}
+
+export {
+  installConnector,
+  syncConnector,
+  uninstallConnector,
+  purgeFrameworkState,
+  resolveCliEntry,
+  resolveUninstallTargets,
+  parseInstallMethod,
+  parseUninstallMethod,
+  installViaMarketplace,
+  uninstallViaMarketplace,
+  upgradeViaMarketplace,
+  marketplaceDoctorChecks
+};
+//# sourceMappingURL=chunk-QADSG2JY.js.map