rush-ai 0.18.1 → 0.19.0

package/dist/chunk-RLKEUPBP.js

@@ -0,0 +1,992 @@
+#!/usr/bin/env node
+import {
+  output
+} from "./chunk-T5S6NCHZ.js";
+
+// src/installers/codex/mirror.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { constants as fsConstants2 } from "fs";
+import {
+  access as access2,
+  cp,
+  mkdir as mkdir2,
+  mkdtemp,
+  readdir,
+  readFile as readFile2,
+  rename as rename2,
+  rm as rm2,
+  stat as stat2,
+  writeFile as writeFile2
+} from "fs/promises";
+import { basename, dirname as dirname2, resolve } from "path";
+
+// src/installers/codex/paths.ts
+import { resolve as pathResolve } from "path";
+function codexHomeDir(home) {
+  return pathResolve(home, ".codex");
+}
+function codexConfigTomlPath(home) {
+  return pathResolve(codexHomeDir(home), "config.toml");
+}
+function codexPluginsCacheDir(home) {
+  return pathResolve(codexHomeDir(home), "plugins", "cache");
+}
+function codexPluginsMarketplacesDir(home) {
+  return pathResolve(codexHomeDir(home), "plugins", "marketplaces");
+}
+function codexMarketplaceDir(home, marketplace) {
+  return pathResolve(codexPluginsMarketplacesDir(home), marketplace);
+}
+function codexMarketplaceManifestPath(marketplaceDir) {
+  return pathResolve(marketplaceDir, ".agents", "plugins", "marketplace.json");
+}
+function codexMarketplacePluginDir(marketplaceDir, pluginName) {
+  return pathResolve(marketplaceDir, "plugins", pluginName);
+}
+function codexPluginVersionDir(home, ref, version) {
+  return pathResolve(
+    codexPluginsCacheDir(home),
+    ref.marketplace,
+    ref.name,
+    version
+  );
+}
+function codexPluginManifestPath(versionDir) {
+  return pathResolve(versionDir, ".codex-plugin", "plugin.json");
+}
+function codexPluginMcpPath(versionDir) {
+  return pathResolve(versionDir, ".mcp.json");
+}
+function codexPluginSkillsDir(versionDir) {
+  return pathResolve(versionDir, "skills");
+}
+function codexConfigBackupPath(home, now) {
+  const ts = formatBackupTimestamp(now);
+  return `${codexConfigTomlPath(home)}.bak.${ts}`;
+}
+function formatBackupTimestamp(date) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const yyyy = date.getUTCFullYear();
+  const mm = pad(date.getUTCMonth() + 1);
+  const dd = pad(date.getUTCDate());
+  const hh = pad(date.getUTCHours());
+  const mi = pad(date.getUTCMinutes());
+  const ss = pad(date.getUTCSeconds());
+  return `${yyyy}${mm}${dd}-${hh}${mi}${ss}`;
+}
+function pluginSectionKey(ref) {
+  return `${ref.name}@${ref.marketplace}`;
+}
+
+// src/installers/codex/toml.ts
+import { randomUUID } from "crypto";
+import { constants as fsConstants } from "fs";
+import {
+  access,
+  copyFile,
+  mkdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  writeFile
+} from "fs/promises";
+import { dirname } from "path";
+import tomlModule from "@iarna/toml";
+var { parse: tomlParse, stringify: tomlStringify } = tomlModule;
+var CodexConfigTomlError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CodexConfigTomlError";
+  }
+};
+var CodexConfigTomlCorruptError = class extends CodexConfigTomlError {
+  constructor(filePath, cause) {
+    super(
+      `Codex config.toml \u89E3\u6790\u5931\u8D25\uFF08${filePath}\uFF09\u3002\u8BF7\u5907\u4EFD\u540E\u624B\u5DE5\u4FEE\u590D\u3002\u539F\u56E0\uFF1A${String(
+        cause?.message ?? cause
+      )}`
+    );
+    this.filePath = filePath;
+    this.cause = cause;
+    this.name = "CodexConfigTomlCorruptError";
+  }
+};
+var CodexConfigTomlConflictError = class extends CodexConfigTomlError {
+  constructor(filePath) {
+    super(
+      `Codex config.toml \u5E76\u53D1\u5199\u51B2\u7A81\uFF1A\u8BFB\u53D6\u548C\u5199\u5165\u4E4B\u95F4 ${filePath} \u88AB\u5176\u4ED6\u8FDB\u7A0B\u4FEE\u6539\u3002\u8BF7\u91CD\u8BD5\u3002`
+    );
+    this.filePath = filePath;
+    this.name = "CodexConfigTomlConflictError";
+  }
+};
+async function readCodexConfig(filePath) {
+  if (!await pathExists(filePath)) {
+    return { data: {}, mtimeMs: null };
+  }
+  const stats = await stat(filePath);
+  const raw = await readFile(filePath, "utf8");
+  try {
+    const parsed = tomlParse(raw);
+    return { data: parsed, mtimeMs: stats.mtimeMs };
+  } catch (err) {
+    throw new CodexConfigTomlCorruptError(filePath, err);
+  }
+}
+async function backupCodexConfig(filePath, backupPath) {
+  if (!await pathExists(filePath)) {
+    return null;
+  }
+  let finalBackup = backupPath;
+  if (await pathExists(finalBackup)) {
+    finalBackup = `${backupPath}.${randomUUID().slice(0, 8)}`;
+  }
+  await copyFile(filePath, finalBackup);
+  return finalBackup;
+}
+async function writeCodexConfig(filePath, data, expectedMtimeMs) {
+  await assertNoMtimeDrift(filePath, expectedMtimeMs);
+  const serialized = tomlStringify(data);
+  await atomicWrite(filePath, serialized);
+  const afterStats = await stat(filePath);
+  return { mtimeMs: afterStats.mtimeMs };
+}
+async function restoreCodexConfigFromBackup(filePath, backupPath) {
+  if (!backupPath || !await pathExists(backupPath)) {
+    if (await pathExists(filePath)) {
+      await rm(filePath, { force: true });
+    }
+    return;
+  }
+  const raw = await readFile(backupPath, "utf8");
+  await atomicWrite(filePath, raw);
+  await rm(backupPath, { force: true }).catch(() => {
+  });
+}
+function setMarketplaceSection(config, name, entry) {
+  const mkts = ensureObjectSection(config, "marketplaces");
+  mkts[name] = { ...entry };
+}
+function removeMarketplaceSection(config, name) {
+  const mkts = config.marketplaces;
+  if (!mkts || typeof mkts !== "object") return;
+  delete mkts[name];
+  if (Object.keys(mkts).length === 0) {
+    delete config.marketplaces;
+  }
+}
+function setPluginEntry(config, key, entry) {
+  const plugins = ensureObjectSection(config, "plugins");
+  plugins[key] = { ...entry };
+}
+function removePluginEntry(config, key) {
+  const plugins = config.plugins;
+  if (!plugins || typeof plugins !== "object") return;
+  delete plugins[key];
+  if (Object.keys(plugins).length === 0) {
+    delete config.plugins;
+  }
+}
+var MCP_OWNER_MARKER_KEY = "_rush_ai_owner";
+function setMcpServerSection(config, serverName, ownerKey, entry) {
+  const servers = ensureObjectSection(config, "mcp_servers");
+  servers[serverName] = { ...entry, [MCP_OWNER_MARKER_KEY]: ownerKey };
+}
+function removeMcpServerSection(config, serverName, expectedOwner) {
+  const servers = config.mcp_servers;
+  if (!servers || typeof servers !== "object") return "absent";
+  const entry = servers[serverName];
+  if (!entry || typeof entry !== "object") return "absent";
+  const owner = entry[MCP_OWNER_MARKER_KEY];
+  if (owner !== expectedOwner) return "foreign";
+  delete servers[serverName];
+  if (Object.keys(servers).length === 0) {
+    delete config.mcp_servers;
+  }
+  return "removed";
+}
+function getMcpServerOwner(config, serverName) {
+  const servers = config.mcp_servers;
+  if (!servers || typeof servers !== "object") return null;
+  const entry = servers[serverName];
+  if (!entry || typeof entry !== "object") return null;
+  const owner = entry[MCP_OWNER_MARKER_KEY];
+  return typeof owner === "string" ? owner : void 0;
+}
+async function pathExists(p) {
+  try {
+    await access(p, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function atomicWrite(filePath, content) {
+  await mkdir(dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(tmp, content, { encoding: "utf8", flag: "w" });
+    await rename(tmp, filePath);
+  } catch (err) {
+    await rm(tmp, { force: true }).catch(() => {
+    });
+    throw err;
+  }
+}
+async function assertNoMtimeDrift(filePath, expectedMtimeMs) {
+  if (expectedMtimeMs === null) {
+    if (await pathExists(filePath)) {
+      throw new CodexConfigTomlConflictError(filePath);
+    }
+    return;
+  }
+  const current = await stat(filePath).catch(() => null);
+  if (current === null) {
+    throw new CodexConfigTomlConflictError(filePath);
+  }
+  if (current.mtimeMs !== expectedMtimeMs) {
+    throw new CodexConfigTomlConflictError(filePath);
+  }
+}
+function ensureObjectSection(config, key) {
+  const existing = config[key];
+  if (existing === void 0) {
+    const fresh = {};
+    config[key] = fresh;
+    return fresh;
+  }
+  if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
+    throw new CodexConfigTomlError(
+      `config.toml \u9876\u5C42 '${key}' \u5DF2\u5B58\u5728\u4F46\u4E0D\u662F object\uFF08type=${Array.isArray(existing) ? "array" : typeof existing}\uFF09\u3002\u8BF7\u624B\u5DE5\u5907\u4EFD\u5E76\u6574\u7406\u8BE5\u5B57\u6BB5\u540E\u91CD\u8BD5\u3002`
+    );
+  }
+  return existing;
+}
+
+// src/installers/codex/mirror.ts
+function isSafePluginName(name) {
+  if (typeof name !== "string" || name.length === 0) return false;
+  if (name === "." || name === "..") return false;
+  if (name.startsWith(".")) return false;
+  if (name.includes("/") || name.includes("\\")) return false;
+  if (name.includes("..")) return false;
+  return /^[A-Za-z0-9_@][A-Za-z0-9._@-]*$/.test(name);
+}
+var DEFAULT_CATEGORY = "Engineering";
+var DEFAULT_CAPABILITIES = ["Read", "Write"];
+async function syncCodexMarketplaceMirror(home, resolved, opts = {}) {
+  const result = {
+    skipped: false,
+    added: [],
+    refreshed: [],
+    preservedFull: [],
+    removed: [],
+    warnings: []
+  };
+  if (!await isDir(codexHomeDir(home))) {
+    result.skipped = true;
+    return result;
+  }
+  const marketplaceDir = codexMarketplaceDir(home, resolved.name);
+  const manifestPath = codexMarketplaceManifestPath(marketplaceDir);
+  const contentLoader = opts.contentLoader ?? (async () => ({}));
+  const fallback = {
+    name: resolved.name,
+    interface: { displayName: resolved.name },
+    plugins: []
+  };
+  const existing = await readCodexMarketplaceCatalog(manifestPath, fallback);
+  const existingByName = new Map(existing.plugins.map((p) => [p.name, p]));
+  const remotePlugins = [];
+  const remoteNames = /* @__PURE__ */ new Set();
+  for (const entry of resolved.manifest.plugins) {
+    if (typeof entry?.name !== "string" || !isSafePluginName(entry.name)) {
+      const display = typeof entry?.name === "string" ? entry.name : "<unnamed>";
+      result.warnings.push(`skipped plugin with unsafe name: ${display}`);
+      output.warn(
+        `[codex] marketplace '${resolved.name}': skipped plugin with unsafe name: ${display}`
+      );
+      continue;
+    }
+    if (remoteNames.has(entry.name)) {
+      result.warnings.push(`duplicate plugin name in manifest: ${entry.name}`);
+      continue;
+    }
+    remotePlugins.push(entry);
+    remoteNames.add(entry.name);
+  }
+  const nextEntries = [];
+  for (const entry of remotePlugins) {
+    const pluginDir = codexMarketplacePluginDir(marketplaceDir, entry.name);
+    const fullState = await detectFullPluginDir(pluginDir);
+    if (fullState === "full") {
+      const prior = existingByName.get(entry.name);
+      const base = prior ?? buildStubCatalogEntry(entry);
+      const fullEntry = {
+        ...base,
+        policy: { installation: "AVAILABLE", authentication: "ON_INSTALL" }
+      };
+      nextEntries.push(fullEntry);
+      result.preservedFull.push(entry.name);
+      continue;
+    }
+    let content = {};
+    try {
+      content = await contentLoader(entry);
+    } catch (err) {
+      result.warnings.push(
+        `contentLoader failed for '${entry.name}': ${err.message}`
+      );
+      output.warn(
+        `[codex] marketplace '${resolved.name}': contentLoader failed for '${entry.name}': ${err.message}`
+      );
+      content = {};
+    }
+    try {
+      await writePluginMaterials(pluginDir, entry, content, resolved.name);
+    } catch (err) {
+      result.warnings.push(
+        `failed to write stub for '${entry.name}': ${err.message}`
+      );
+      output.warn(
+        `[codex] marketplace '${resolved.name}': failed to write stub for '${entry.name}': ${err.message}`
+      );
+      continue;
+    }
+    nextEntries.push(buildStubCatalogEntry(entry, content));
+    if (existingByName.has(entry.name)) {
+      result.refreshed.push(entry.name);
+    } else {
+      result.added.push(entry.name);
+    }
+  }
+  for (const prior of existing.plugins) {
+    if (remoteNames.has(prior.name)) continue;
+    if (!isSafePluginName(prior.name)) {
+      result.warnings.push(
+        `dropped catalog entry with unsafe name: ${prior.name}`
+      );
+      output.warn(
+        `[codex] marketplace '${resolved.name}': dropped catalog entry with unsafe name: ${prior.name}`
+      );
+      result.removed.push(prior.name);
+      continue;
+    }
+    const pluginDir = codexMarketplacePluginDir(marketplaceDir, prior.name);
+    if (await detectFullPluginDir(pluginDir) === "full") {
+      nextEntries.push(prior);
+      output.warn(
+        `[codex] marketplace '${resolved.name}': installed plugin '${prior.name}' no longer in remote catalog; keeping entry. Run 'rush-ai plugin uninstall ${prior.name}@${resolved.name}' if intended.`
+      );
+      continue;
+    }
+    await rm2(pluginDir, { recursive: true, force: true }).catch(() => {
+    });
+    result.removed.push(prior.name);
+  }
+  nextEntries.sort((a, b) => a.name.localeCompare(b.name));
+  const nextCatalog = {
+    name: existing.name || resolved.name,
+    interface: existing.interface ?? fallback.interface,
+    plugins: nextEntries
+  };
+  await writeFileAtomic(
+    manifestPath,
+    `${JSON.stringify(nextCatalog, null, 2)}
+`
+  );
+  try {
+    await registerMarketplaceInCodexConfig({
+      home,
+      marketplaceName: resolved.name,
+      marketplaceDir,
+      now: opts.now ?? (() => /* @__PURE__ */ new Date())
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    result.warnings.push(
+      `failed to register [marketplaces.${resolved.name}] in config.toml: ${msg}`
+    );
+    output.warn(
+      `[codex] marketplace '${resolved.name}': failed to register in config.toml: ${msg}`
+    );
+  }
+  return result;
+}
+async function registerMarketplaceInCodexConfig(args) {
+  const cfgPath = codexConfigTomlPath(args.home);
+  await backupCodexConfig(
+    cfgPath,
+    codexConfigBackupPath(args.home, args.now())
+  );
+  const { data, mtimeMs } = await readCodexConfig(cfgPath);
+  setMarketplaceSection(data, args.marketplaceName, {
+    last_updated: args.now().toISOString(),
+    source_type: "local",
+    source: args.marketplaceDir
+  });
+  await writeCodexConfig(cfgPath, data, mtimeMs);
+}
+async function writeCodexMarketplacePluginMirror(input) {
+  const pluginParent = dirname2(input.pluginDir);
+  const pluginBase = basename(input.pluginDir);
+  await mkdir2(pluginParent, { recursive: true });
+  const tmpPluginDir = await mkdtemp(
+    resolve(pluginParent, `.${pluginBase}.tmp-`)
+  );
+  const backupPluginDir = await mkdtemp(
+    resolve(pluginParent, `.${pluginBase}.bak-`)
+  );
+  let hadExistingPluginDir = false;
+  let swappedPluginDir = false;
+  try {
+    await rm2(tmpPluginDir, { recursive: true, force: true });
+    await rm2(backupPluginDir, { recursive: true, force: true }).catch(() => {
+    });
+    await cp(input.versionDir, tmpPluginDir, {
+      recursive: true,
+      dereference: false,
+      preserveTimestamps: true,
+      verbatimSymlinks: true
+    });
+    hadExistingPluginDir = await pathExists2(input.pluginDir);
+    if (hadExistingPluginDir) {
+      await rename2(input.pluginDir, backupPluginDir);
+    }
+    await rename2(tmpPluginDir, input.pluginDir);
+    swappedPluginDir = true;
+    await upsertCodexCatalogPluginFull(input.marketplaceDir, input.plugin);
+    if (hadExistingPluginDir) {
+      await rm2(backupPluginDir, { recursive: true, force: true });
+    }
+  } catch (err) {
+    await rm2(tmpPluginDir, { recursive: true, force: true }).catch(() => {
+    });
+    let restoredBackup = false;
+    if (hadExistingPluginDir && await pathExists2(backupPluginDir)) {
+      let displacedPluginDir = null;
+      try {
+        if (await pathExists2(input.pluginDir)) {
+          displacedPluginDir = await mkdtemp(
+            resolve(pluginParent, `.${pluginBase}.failed-`)
+          );
+          await rm2(displacedPluginDir, { recursive: true, force: true });
+          await rename2(input.pluginDir, displacedPluginDir);
+        }
+        await rename2(backupPluginDir, input.pluginDir);
+        restoredBackup = true;
+        if (displacedPluginDir) {
+          await rm2(displacedPluginDir, { recursive: true, force: true }).catch(
+            () => {
+            }
+          );
+        }
+      } catch {
+        if (displacedPluginDir && !await pathExists2(input.pluginDir) && await pathExists2(displacedPluginDir)) {
+          await rename2(displacedPluginDir, input.pluginDir).catch(() => {
+          });
+        }
+      }
+    } else if (swappedPluginDir) {
+      await rm2(input.pluginDir, { recursive: true, force: true }).catch(
+        () => {
+        }
+      );
+    }
+    if (restoredBackup || !hadExistingPluginDir) {
+      await rm2(backupPluginDir, { recursive: true, force: true }).catch(
+        () => {
+        }
+      );
+    }
+    throw err;
+  }
+}
+async function upsertCodexCatalogPluginFull(marketplaceDir, plugin) {
+  const manifestPath = codexMarketplaceManifestPath(marketplaceDir);
+  const fallback = {
+    name: plugin.ref.marketplace,
+    interface: { displayName: plugin.ref.marketplace },
+    plugins: []
+  };
+  const catalog = await readCodexMarketplaceCatalog(manifestPath, fallback);
+  const nextEntry = {
+    name: plugin.ref.name,
+    source: { source: "local", path: `./plugins/${plugin.ref.name}` },
+    policy: { installation: "AVAILABLE", authentication: "ON_INSTALL" },
+    category: buildInterfaceCategory(plugin.manifest)
+  };
+  if (plugin.manifest.description !== void 0) {
+    nextEntry.description = plugin.manifest.description;
+  }
+  if (typeof plugin.manifest.version === "string") {
+    nextEntry.version = plugin.manifest.version;
+  }
+  const next = [
+    ...catalog.plugins.filter((entry) => entry.name !== plugin.ref.name),
+    nextEntry
+  ].sort((a, b) => a.name.localeCompare(b.name));
+  await writeFileAtomic(
+    manifestPath,
+    `${JSON.stringify({ ...catalog, plugins: next }, null, 2)}
+`
+  );
+}
+async function downgradeCodexCatalogEntryToStub(marketplaceDir, pluginName) {
+  const manifestPath = codexMarketplaceManifestPath(marketplaceDir);
+  const pluginDir = codexMarketplacePluginDir(marketplaceDir, pluginName);
+  await rm2(pluginDir, { recursive: true, force: true }).catch(() => {
+  });
+  if (!await pathExists2(manifestPath)) return;
+  try {
+    const fallback = {
+      name: "",
+      interface: {},
+      plugins: []
+    };
+    const catalog = await readCodexMarketplaceCatalog(manifestPath, fallback);
+    const next = catalog.plugins.map((entry) => {
+      if (entry.name !== pluginName) return entry;
+      return {
+        ...entry,
+        policy: {
+          installation: "NOT_AVAILABLE",
+          authentication: "ON_INSTALL"
+        }
+      };
+    });
+    await writeFileAtomic(
+      manifestPath,
+      `${JSON.stringify({ ...catalog, plugins: next }, null, 2)}
+`
+    );
+  } catch {
+  }
+}
+async function readCodexMarketplaceCatalog(manifestPath, fallback) {
+  if (!await pathExists2(manifestPath)) return fallback;
+  try {
+    const parsed = JSON.parse(await readFile2(manifestPath, "utf8"));
+    return {
+      name: typeof parsed.name === "string" ? parsed.name : fallback.name,
+      interface: parsed.interface && typeof parsed.interface === "object" && !Array.isArray(parsed.interface) ? parsed.interface : fallback.interface,
+      plugins: Array.isArray(parsed.plugins) ? parsed.plugins.filter(isCatalogPluginEntry) : fallback.plugins
+    };
+  } catch {
+    return fallback;
+  }
+}
+function isCatalogPluginEntry(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && typeof value.name === "string";
+}
+function buildStubCatalogEntry(entry, content = {}) {
+  const description = pickNonEmptyString(entry.description) ?? pickNonEmptyString(content.manifest?.description);
+  const version = pickNonEmptyString(entry.version) ?? pickNonEmptyString(content.manifest?.version);
+  const m = content.manifest ?? void 0;
+  const ifaceIn = m?.interface ?? {};
+  const entryCategory = pickNonEmptyString(
+    entry.category
+  );
+  const category = pickNonEmptyString(ifaceIn.category) ?? normalizeCategory(entryCategory) ?? DEFAULT_CATEGORY;
+  const out = {
+    name: entry.name,
+    source: { source: "local", path: `./plugins/${entry.name}` },
+    // stub 入口 → 标记为 NOT_AVAILABLE，让 Codex UI 禁用"连接"按钮，
+    // 因为点击连接只会写一份没有 MCP key 的伪安装。真正安装走
+    // `npx rush-ai@latest plugin install <name>@<marketplace>`。
+    // 已装 full 路径在 upsertCodexCatalogPluginFull 中覆写为 AVAILABLE。
+    policy: { installation: "NOT_AVAILABLE", authentication: "ON_INSTALL" },
+    category
+  };
+  if (description !== void 0) out.description = description;
+  if (version !== void 0) out.version = version;
+  return out;
+}
+function buildPluginJson(entry, content, marketplaceName) {
+  const m = content.manifest ?? void 0;
+  const author = m?.author ?? (entry.author && typeof entry.author === "object" ? entry.author : void 0);
+  const homepage = pickNonEmptyString(m?.homepage) ?? pickNonEmptyString(entry.homepage);
+  const license = pickNonEmptyString(m?.license) ?? pickNonEmptyString(entry.license);
+  const keywords = Array.isArray(m?.keywords) && m.keywords.length > 0 ? m.keywords : Array.isArray(entry.keywords) && entry.keywords.length > 0 ? entry.keywords : void 0;
+  const entryCategory = pickNonEmptyString(
+    entry.category
+  );
+  const sourceUrl = extractSourceUrl(entry.source);
+  const description = pickNonEmptyString(m?.description) ?? pickNonEmptyString(entry.description) ?? entry.name;
+  const version = pickNonEmptyString(m?.version) ?? pickNonEmptyString(entry.version) ?? "0.0.0";
+  const ifaceIn = m?.interface ?? {};
+  const developerName = pickNonEmptyString(ifaceIn.developerName) ?? pickNonEmptyString(author?.name);
+  const websiteURL = pickNonEmptyString(ifaceIn.websiteURL) ?? sourceUrl ?? homepage;
+  const category = pickNonEmptyString(ifaceIn.category) ?? normalizeCategory(entryCategory) ?? DEFAULT_CATEGORY;
+  const capabilities = Array.isArray(ifaceIn.capabilities) && ifaceIn.capabilities.length > 0 ? [...ifaceIn.capabilities] : [...DEFAULT_CAPABILITIES];
+  const installCmd = `npx rush-ai@latest plugin install ${entry.name}@${marketplaceName} --target codex`;
+  const shortHintPrefix = "\u26A0 \u9700\u5728\u7EC8\u7AEF\u5B89\u88C5 \uFF5C ";
+  const authorShort = pickNonEmptyString(ifaceIn.shortDescription) ?? description;
+  const baseLongDescription = pickNonEmptyString(ifaceIn.longDescription) ?? pickNonEmptyString(ifaceIn.shortDescription) ?? description;
+  const extraLinks = [];
+  if (homepage !== void 0 && homepage !== websiteURL) {
+    extraLinks.push(`\u5B98\u7F51\uFF1A${homepage}`);
+  }
+  if (sourceUrl !== void 0 && sourceUrl !== websiteURL && sourceUrl !== homepage) {
+    extraLinks.push(`\u6E90\u4EE3\u7801\uFF1A${sourceUrl}`);
+  }
+  const extraLinksSection = extraLinks.length > 0 ? `
+
+${extraLinks.join("\n")}` : "";
+  const installSection = `\u2014\u2014\u2014
+\u26A0 Codex \u684C\u9762\u7AEF\u7684"\u8FDE\u63A5"\u6309\u94AE\u65E0\u6CD5\u5B8C\u6574\u5B89\u88C5\u672C\u63D2\u4EF6
+\u8BF7\u5728\u7EC8\u7AEF\u6267\u884C\u4EE5\u4E0B\u547D\u4EE4\u5B8C\u6210\u5B89\u88C5\uFF1A
+${installCmd}`;
+  const longDescription = `${baseLongDescription}${extraLinksSection}
+
+${installSection}`;
+  const defaultPrompt = Array.isArray(ifaceIn.defaultPrompt) ? [...ifaceIn.defaultPrompt] : [];
+  if (defaultPrompt.length === 0) {
+    defaultPrompt.push(installCmd);
+  }
+  const ifaceOut = {
+    displayName: pickNonEmptyString(ifaceIn.displayName) ?? entry.name,
+    shortDescription: `${shortHintPrefix}${authorShort}`,
+    longDescription,
+    category,
+    capabilities,
+    defaultPrompt
+  };
+  if (developerName !== void 0) ifaceOut.developerName = developerName;
+  if (websiteURL !== void 0) ifaceOut.websiteURL = websiteURL;
+  if (pickNonEmptyString(ifaceIn.privacyPolicyURL) !== void 0)
+    ifaceOut.privacyPolicyURL = ifaceIn.privacyPolicyURL;
+  if (pickNonEmptyString(ifaceIn.termsOfServiceURL) !== void 0)
+    ifaceOut.termsOfServiceURL = ifaceIn.termsOfServiceURL;
+  if (pickNonEmptyString(ifaceIn.brandColor) !== void 0)
+    ifaceOut.brandColor = ifaceIn.brandColor;
+  if (pickNonEmptyString(ifaceIn.composerIcon) !== void 0)
+    ifaceOut.composerIcon = ifaceIn.composerIcon;
+  if (pickNonEmptyString(ifaceIn.logo) !== void 0)
+    ifaceOut.logo = ifaceIn.logo;
+  if (Array.isArray(ifaceIn.screenshots) && ifaceIn.screenshots.length > 0)
+    ifaceOut.screenshots = [...ifaceIn.screenshots];
+  const out = {
+    // marker：让 detectFullPluginDir 可靠区分 sync vs install 写出的目录。
+    // Codex 不知道这个字段，会被忽略；marker 必须是合法 JSON 字段名才能被 plugin.json 接受。
+    [STUB_MARKER_KEY]: STUB_MARKER_VALUE,
+    name: entry.name,
+    version,
+    description,
+    skills: "./skills/",
+    interface: ifaceOut
+  };
+  if (author && typeof author === "object") {
+    out.author = { ...author };
+  }
+  if (homepage !== void 0) {
+    out.homepage = homepage;
+  }
+  if (sourceUrl !== void 0) {
+    out.repository = sourceUrl;
+  }
+  if (license !== void 0) {
+    out.license = license;
+  }
+  if (keywords !== void 0) {
+    out.keywords = [...keywords];
+  }
+  if (hasMcpServers(content)) {
+    out.mcpServers = "./.mcp.json";
+  }
+  return out;
+}
+function extractSourceUrl(source) {
+  if (!source || typeof source === "string") return void 0;
+  const obj = source;
+  const url = obj.url;
+  if (typeof url !== "string" || url.length === 0) return void 0;
+  if (!/^https?:\/\//i.test(url)) return void 0;
+  return url.replace(/\.git$/, "");
+}
+function normalizeCategory(raw) {
+  if (raw === void 0) return void 0;
+  const lower = raw.toLowerCase().trim();
+  const map = {
+    development: "Engineering",
+    data: "Engineering",
+    devops: "Engineering",
+    design: "Design",
+    productivity: "Productivity",
+    security: "Security",
+    research: "Research",
+    automation: "Productivity",
+    integration: "Engineering"
+  };
+  if (lower in map) return map[lower];
+  return lower.charAt(0).toUpperCase() + lower.slice(1);
+}
+async function writePluginMaterials(pluginDir, entry, content, marketplaceName) {
+  const manifestPath = codexPluginManifestPath(pluginDir);
+  await mkdir2(dirname2(manifestPath), { recursive: true });
+  await rm2(codexPluginMcpPath(pluginDir), { force: true }).catch(() => {
+  });
+  await rm2(codexPluginSkillsDir(pluginDir), {
+    recursive: true,
+    force: true
+  }).catch(() => {
+  });
+  const pluginJson = buildPluginJson(entry, content, marketplaceName);
+  await writeFileAtomic(
+    manifestPath,
+    `${JSON.stringify(pluginJson, null, 2)}
+`
+  );
+  if (hasMcpServers(content)) {
+    const mcpPath = codexPluginMcpPath(pluginDir);
+    await writeFileAtomic(
+      mcpPath,
+      `${JSON.stringify({ mcpServers: content.mcpServers }, null, 2)}
+`
+    );
+  }
+  if (content.skillsSourceDir && await isDir(content.skillsSourceDir)) {
+    const skillsDir = codexPluginSkillsDir(pluginDir);
+    await mkdir2(skillsDir, { recursive: true });
+    await cp(content.skillsSourceDir, skillsDir, {
+      recursive: true,
+      dereference: false,
+      preserveTimestamps: true,
+      verbatimSymlinks: true
+    });
+  } else if (Array.isArray(content.skillsPlaceholders) && content.skillsPlaceholders.length > 0) {
+    const installCmd = pickNonEmptyString(content.installCommand) ?? `npx rush-ai@latest plugin install ${entry.name}@${marketplaceName} --target codex`;
+    const pluginWebUrl = pickNonEmptyString(content.pluginWebUrl);
+    const skillsDir = codexPluginSkillsDir(pluginDir);
+    const usedDirs = /* @__PURE__ */ new Set();
+    for (const skill of content.skillsPlaceholders) {
+      if (!isSafeSkillName(skill.name)) continue;
+      const dirName = uniqueDirName(slugifySkillName(skill.name), usedDirs);
+      usedDirs.add(dirName);
+      const skillDir = resolve(skillsDir, dirName);
+      await mkdir2(skillDir, { recursive: true });
+      const rawSkillMd = pickNonEmptyString(skill.rawSkillMd);
+      if (rawSkillMd !== void 0) {
+        const rewritten = rewriteSkillMdName(rawSkillMd, dirName);
+        await writeFileAtomic(resolve(skillDir, "SKILL.md"), rewritten);
+        continue;
+      }
+      const desc = pickNonEmptyString(skill.description) ?? `Skill ${skill.name}`;
+      const fullDesc = skill.name === dirName ? desc : `${skill.name} \u2014 ${desc}`;
+      const skillUrl = pickNonEmptyString(skill.url);
+      const body = buildSkillPlaceholderBody({
+        name: skill.name,
+        description: fullDesc,
+        skillUrl,
+        pluginWebUrl,
+        installCmd
+      });
+      const md = `---
+name: ${jsonQuote(dirName)}
+description: ${jsonQuote(fullDesc)}
+---
+
+${body}
+`;
+      await writeFileAtomic(resolve(skillDir, "SKILL.md"), md);
+    }
+  }
+}
+function rewriteSkillMdName(raw, dirName) {
+  const text = raw.replace(/\r\n/g, "\n");
+  if (!text.startsWith("---\n")) {
+    return `---
+name: ${jsonQuote(dirName)}
+description: ${jsonQuote(dirName)}
+---
+
+` + text;
+  }
+  const lines = text.split("\n");
+  let closeIdx = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i] === "---") {
+      closeIdx = i;
+      break;
+    }
+  }
+  if (closeIdx === -1) {
+    return `---
+name: ${jsonQuote(dirName)}
+description: ${jsonQuote(dirName)}
+---
+
+` + text;
+  }
+  let foundName = false;
+  for (let i = 1; i < closeIdx; i++) {
+    const line = lines[i] ?? "";
+    if (/^name\s*:/.test(line)) {
+      lines[i] = `name: ${jsonQuote(dirName)}`;
+      foundName = true;
+      break;
+    }
+  }
+  if (!foundName) {
+    lines.splice(1, 0, `name: ${jsonQuote(dirName)}`);
+  }
+  return lines.join("\n");
+}
+function buildSkillPlaceholderBody(input) {
+  const lines = [];
+  lines.push(`# ${input.name}`);
+  lines.push("");
+  lines.push(input.description);
+  lines.push("");
+  lines.push(
+    "> \u8FD9\u662F rush-ai marketplace \u540C\u6B65\u51FA\u7684\u5360\u4F4D skill \u2014\u2014 skill \u5B8C\u6574\u5185\u5BB9\uFF08trigger / \u64CD\u4F5C\u6B65\u9AA4 / \u63D0\u793A\u8BCD\uFF09\u5C1A\u672A\u4E0B\u8F7D\u3002"
+  );
+  lines.push(">");
+  lines.push("> \u5728\u7EC8\u7AEF\u6267\u884C\u4EE5\u4E0B\u547D\u4EE4\u4EE5\u5B8C\u6574\u5B89\u88C5\uFF1A");
+  lines.push(">");
+  lines.push("> ```bash");
+  lines.push(`> ${input.installCmd}`);
+  lines.push("> ```");
+  if (input.skillUrl !== void 0) {
+    lines.push(">");
+    lines.push(`> \u4E5F\u53EF\u5728 web \u7AD9\u70B9\u67E5\u770B\uFF1A[${input.name}](${input.skillUrl})`);
+  }
+  if (input.pluginWebUrl !== void 0) {
+    lines.push(">");
+    lines.push(`> \u6D4F\u89C8\u6240\u5C5E plugin\uFF1A${input.pluginWebUrl}`);
+  }
+  return lines.join("\n");
+}
+function jsonQuote(s) {
+  return JSON.stringify(s);
+}
+function slugifySkillName(name) {
+  return name.replace(/^@/, "").replace(/[\\/.]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "") || "skill";
+}
+function uniqueDirName(base, used) {
+  if (!used.has(base)) return base;
+  let i = 2;
+  while (used.has(`${base}-${i}`)) i += 1;
+  return `${base}-${i}`;
+}
+function isSafeSkillName(name) {
+  if (typeof name !== "string" || name.length === 0) return false;
+  if (name === "." || name === "..") return false;
+  if (name.startsWith(".")) return false;
+  if (name.includes("\\")) return false;
+  if (name.includes("..")) return false;
+  const slashCount = (name.match(/\//g) ?? []).length;
+  if (slashCount > 1) return false;
+  if (slashCount === 1 && !name.startsWith("@")) return false;
+  return /^@?[A-Za-z0-9_][A-Za-z0-9._@/-]*$/.test(name);
+}
+function hasMcpServers(content) {
+  return !!content.mcpServers && typeof content.mcpServers === "object" && Object.keys(content.mcpServers).length > 0;
+}
+function pickNonEmptyString(value) {
+  if (typeof value === "string" && value.length > 0) return value;
+  return void 0;
+}
+var STUB_MARKER_KEY = "x-rush-mirror";
+var STUB_MARKER_VALUE = "stub";
+async function detectFullPluginDir(pluginDir) {
+  if (!await isDir(pluginDir)) return "stub";
+  const manifestPath = codexPluginManifestPath(pluginDir);
+  if (await pathExists2(manifestPath)) {
+    try {
+      const raw = await readFile2(manifestPath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed[STUB_MARKER_KEY] === STUB_MARKER_VALUE) {
+        return "stub";
+      }
+    } catch {
+    }
+  }
+  if (await dirHasEntries(codexPluginSkillsDir(pluginDir))) {
+    return "full";
+  }
+  const mcpPath = codexPluginMcpPath(pluginDir);
+  if (await pathExists2(mcpPath)) {
+    try {
+      const raw = await readFile2(mcpPath, "utf8");
+      if (!/\$\{[^}]+\}/.test(raw)) {
+        return "full";
+      }
+    } catch {
+    }
+  }
+  return "stub";
+}
+async function dirHasEntries(dir) {
+  if (!await isDir(dir)) return false;
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  return entries.length > 0;
+}
+function buildInterfaceCategory(manifest) {
+  return manifest.interface?.category ?? DEFAULT_CATEGORY;
+}
+async function writeFileAtomic(filePath, content) {
+  await mkdir2(dirname2(filePath), { recursive: true });
+  const tmp = `${filePath}.${randomUUID2()}.tmp`;
+  try {
+    await writeFile2(tmp, content, { encoding: "utf8", flag: "w" });
+    await rename2(tmp, filePath);
+  } catch (err) {
+    await rm2(tmp, { force: true }).catch(() => {
+    });
+    throw err;
+  }
+}
+async function pathExists2(p) {
+  try {
+    await access2(p, fsConstants2.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isDir(p) {
+  try {
+    const s = await stat2(p);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export {
+  codexHomeDir,
+  codexConfigTomlPath,
+  codexMarketplaceDir,
+  codexMarketplaceManifestPath,
+  codexMarketplacePluginDir,
+  codexPluginVersionDir,
+  codexPluginManifestPath,
+  codexPluginMcpPath,
+  codexPluginSkillsDir,
+  codexConfigBackupPath,
+  pluginSectionKey,
+  readCodexConfig,
+  backupCodexConfig,
+  writeCodexConfig,
+  restoreCodexConfigFromBackup,
+  setMarketplaceSection,
+  removeMarketplaceSection,
+  setPluginEntry,
+  removePluginEntry,
+  setMcpServerSection,
+  removeMcpServerSection,
+  getMcpServerOwner,
+  syncCodexMarketplaceMirror,
+  writeCodexMarketplacePluginMirror,
+  upsertCodexCatalogPluginFull,
+  downgradeCodexCatalogEntryToStub,
+  readCodexMarketplaceCatalog
+};
+//# sourceMappingURL=chunk-RLKEUPBP.js.map