rush-ai 0.13.0 → 0.14.0

package/dist/index.js

@@ -5,9 +5,10 @@ import {
 import {
   AtomicJsonConflictError,
   pathExists,
+  promptCredentials,
   readJsonFile,
   writeJsonFile
-} from "./chunk-V7P2TZZ4.js";
+} from "./chunk-GDSJUMK4.js";
 import {
   ApiError,
   AuthError,
@@ -403,7 +404,7 @@ function getApiBaseUrl() {
 async function loginViaBrowser(jsonMode) {
   const baseUrl = getApiBaseUrl();
   const state = randomBytes(16).toString("hex");
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve23, reject) => {
     let authSaved = false;
     const rejectLogin = (error) => {
       clearAuthConfig();
@@ -506,7 +507,7 @@ async function loginViaBrowser(jsonMode) {
             );
           }
         }
-        resolve21();
+        resolve23();
       } catch (err) {
         server.close();
         const authError = err instanceof AuthError ? err : new AuthError(
@@ -943,9 +944,30 @@ function gitAddAndCommit(projectPath, message) {
     }
   });
 }
+function getRemoteDefaultBranch(url) {
+  try {
+    const out = execFileSync("git", ["ls-remote", "--symref", url, "HEAD"], {
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf-8",
+      timeout: 3e4,
+      env: {
+        ...process.env,
+        GIT_TERMINAL_PROMPT: "0",
+        GIT_ASKPASS: "true",
+        SSH_ASKPASS: "true"
+      }
+    });
+    const m = out.match(/^ref:\s+refs\/heads\/(\S+)\s+HEAD/m);
+    return m?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
 function gitPushUrl(projectPath, url) {
+  const remoteDefault = getRemoteDefaultBranch(url);
+  const refspec = remoteDefault ? `HEAD:${remoteDefault}` : "HEAD";
   try {
-    execFileSync("git", ["push", url, "HEAD", "--force"], {
+    execFileSync("git", ["push", url, refspec, "--force"], {
       cwd: projectPath,
       stdio: "pipe",
       timeout: 3e5,
@@ -2350,19 +2372,19 @@ function registerDoctorCommand(program) {
 }
 
 // src/marketplaces/cache.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { constants as fsConstants3 } from "fs";
 import {
   access as access3,
-  mkdir as mkdir2,
+  mkdir as mkdir3,
   readdir,
   readFile as readFile3,
-  rename,
-  rm as rm2,
-  writeFile as writeFile2
+  rename as rename2,
+  rm as rm3,
+  writeFile as writeFile3
 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname2, resolve as resolve6 } from "path";
+import { dirname as dirname2, resolve as resolve7 } from "path";
 
 // src/marketplaces/directory.ts
 import { stat as fsStat } from "fs/promises";
@@ -2818,6 +2840,204 @@ async function detectCacheState(cacheDir) {
   }
 }
 
+// src/marketplaces/rush.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import { randomUUID } from "crypto";
+import { mkdir as mkdir2, rename, rm as rm2, stat, writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve6 } from "path";
+async function fetchRushMarketplace(source, opts = {}) {
+  const fetchFn = opts.fetchFn ?? fetch;
+  const url = `${inferProtocol(source.host)}${source.host}/api/marketplace`;
+  const headers = {
+    Accept: "application/json"
+  };
+  if (opts.token) {
+    headers.Authorization = `Bearer ${opts.token}`;
+  }
+  const response = await fetchFn(url, { headers });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch rush marketplace from ${url}: ${response.status} ${response.statusText}`
+    );
+  }
+  const data = await response.json();
+  if (!data.plugins || !Array.isArray(data.plugins)) {
+    throw new Error(
+      `Invalid marketplace response from ${url}: missing 'plugins' array`
+    );
+  }
+  return data;
+}
+async function fetchRushPlugin(source, pluginSlug, opts = {}) {
+  const fetchFn = opts.fetchFn ?? fetch;
+  const url = `${inferProtocol(source.host)}${source.host}/api/marketplace/${encodeURIComponent(pluginSlug)}`;
+  const headers = {
+    Accept: "application/json"
+  };
+  if (opts.token) {
+    headers.Authorization = `Bearer ${opts.token}`;
+  }
+  const response = await fetchFn(url, { headers });
+  if (response.status === 401) {
+    throw new Error(
+      `Plugin '${pluginSlug}' requires authentication. Run 'rush-ai login' first.`
+    );
+  }
+  if (response.status === 404) {
+    throw new Error(
+      `Plugin '${pluginSlug}' not found in rush marketplace at ${source.host}`
+    );
+  }
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch plugin '${pluginSlug}' from ${url}: ${response.status} ${response.statusText}`
+    );
+  }
+  return await response.json();
+}
+async function materializeRushPlugin(source, pluginSlug, targetDir, opts = {}) {
+  validateSlug(pluginSlug, "plugin slug");
+  const manifest = await fetchRushPlugin(source, pluginSlug, opts);
+  let mcpServers = {};
+  if (manifest.mcpServers && Object.keys(manifest.mcpServers).length > 0) {
+    mcpServers = { ...manifest.mcpServers };
+    if (opts.secrets && Object.keys(opts.secrets).length > 0) {
+      mcpServers = substituteMcpSecrets(mcpServers, opts.secrets);
+    }
+  }
+  const pluginJson = {
+    name: manifest.name,
+    version: manifest.version || "1.0.0",
+    description: manifest.description,
+    ...Object.keys(mcpServers).length > 0 ? { mcpServers } : {}
+  };
+  const tmpDir = `${targetDir}.${randomUUID()}.tmp`;
+  try {
+    const pluginJsonDir = resolve6(tmpDir, ".claude-plugin");
+    await mkdir2(pluginJsonDir, { recursive: true });
+    await writeFile2(
+      resolve6(pluginJsonDir, "plugin.json"),
+      `${JSON.stringify(pluginJson, null, 2)}
+`,
+      "utf8"
+    );
+    if (manifest.skills && manifest.skills.length > 0) {
+      await writeFile2(
+        resolve6(tmpDir, "skills.json"),
+        '{"skills":{}}\n',
+        "utf8"
+      );
+      const registryUrl = `${inferProtocol(source.host)}${source.host}`;
+      for (const skill of manifest.skills) {
+        try {
+          const args = [
+            "-y",
+            "reskill@latest",
+            "install",
+            skill.name,
+            "--no-save",
+            "--skip-manifest",
+            "-y",
+            "-f",
+            "-r",
+            registryUrl,
+            ...opts.token ? ["-t", opts.token] : []
+          ];
+          execFileSync4("npx", args, {
+            cwd: tmpDir,
+            timeout: 6e4,
+            stdio: "pipe"
+          });
+        } catch (err) {
+          const stderr = err && typeof err === "object" && "stderr" in err ? err.stderr?.toString() ?? "" : "";
+          if (stderr.includes("401") || stderr.includes("403") || stderr.includes("Unauthorized") || stderr.includes("Forbidden")) {
+            throw new SkillAuthError(skill.name, 401);
+          }
+          output.warn(
+            `  Warning: failed to install skill '${skill.name}': ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+    }
+    const dotSkillsDir = resolve6(tmpDir, ".skills");
+    const skillsDir = resolve6(tmpDir, "skills");
+    if (await stat(dotSkillsDir).then((s) => s.isDirectory()).catch(() => false)) {
+      if (!await stat(skillsDir).then((s) => s.isDirectory()).catch(() => false)) {
+        await rename(dotSkillsDir, skillsDir);
+      }
+    }
+    await rm2(resolve6(tmpDir, "skills.json"), { force: true });
+    await rm2(resolve6(tmpDir, ".cursor"), { recursive: true, force: true });
+    await rm2(resolve6(tmpDir, ".claude"), { recursive: true, force: true });
+    await rm2(resolve6(tmpDir, ".codex"), { recursive: true, force: true });
+    await rm2(resolve6(tmpDir, ".github"), { recursive: true, force: true });
+    await rm2(resolve6(tmpDir, ".opencode"), { recursive: true, force: true });
+    await rm2(targetDir, { recursive: true, force: true });
+    await mkdir2(resolve6(targetDir, ".."), { recursive: true });
+    await rename(tmpDir, targetDir);
+  } catch (err) {
+    await rm2(tmpDir, { recursive: true, force: true }).catch(() => {
+    });
+    throw err;
+  }
+  return manifest;
+}
+var SkillAuthError = class extends Error {
+  constructor(skillName, status) {
+    super(
+      `Skill '${skillName}' requires authentication (HTTP ${status}). Run 'rush-ai auth login' first.`
+    );
+    this.name = "SkillAuthError";
+  }
+};
+function substituteMcpSecrets(mcpServers, secrets) {
+  const result = {};
+  for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+    if (!serverConfig || typeof serverConfig !== "object") {
+      result[serverName] = serverConfig;
+      continue;
+    }
+    const cfg = { ...serverConfig };
+    if (cfg.env && typeof cfg.env === "object") {
+      const env = {};
+      for (const [k, v] of Object.entries(cfg.env)) {
+        env[k] = substituteValue(v, secrets);
+      }
+      cfg.env = env;
+    }
+    if (cfg.headers && typeof cfg.headers === "object") {
+      const headers = {};
+      for (const [k, v] of Object.entries(
+        cfg.headers
+      )) {
+        headers[k] = substituteValue(v, secrets);
+      }
+      cfg.headers = headers;
+    }
+    result[serverName] = cfg;
+  }
+  return result;
+}
+function substituteValue(value, secrets) {
+  return value.replace(/\$\{([^}]+)\}/g, (match, key) => {
+    return key in secrets ? secrets[key] : match;
+  });
+}
+function validateSlug(value, label) {
+  if (!value || value.includes("..") || value.startsWith("/") || value.includes("\0")) {
+    throw new Error(
+      `Invalid ${label} '${value}': must not be empty, contain '..', start with '/', or contain null bytes.`
+    );
+  }
+}
+function inferProtocol(host) {
+  const hostname = host.split(":")[0];
+  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "0.0.0.0") {
+    return "http://";
+  }
+  return "https://";
+}
+
 // src/marketplaces/cache.ts
 var MARKETPLACE_CACHE_RELATIVE_PATH = ".rush/marketplaces";
 var CACHE_META_FILENAME = ".rush-marketplace-source.json";
@@ -2844,10 +3064,10 @@ var MarketplaceCache = class {
   gitRunner;
   constructor(opts = {}) {
     if (opts.cacheBaseDir) {
-      this.cacheBaseDir = resolve6(opts.cacheBaseDir);
+      this.cacheBaseDir = resolve7(opts.cacheBaseDir);
     } else {
       const home = opts.home ?? homedir3();
-      this.cacheBaseDir = resolve6(home, MARKETPLACE_CACHE_RELATIVE_PATH);
+      this.cacheBaseDir = resolve7(home, MARKETPLACE_CACHE_RELATIVE_PATH);
     }
     if (opts.gitRunner) {
       this.gitRunner = opts.gitRunner;
@@ -2860,7 +3080,7 @@ var MarketplaceCache = class {
         `Invalid marketplace name '${name}'. Names must be non-empty and cannot contain '/' or '..'.`
       );
     }
-    return resolve6(this.cacheBaseDir, name);
+    return resolve7(this.cacheBaseDir, name);
   }
   /**
    * 添加一个 marketplace 到本地 cache。
@@ -2900,7 +3120,7 @@ var MarketplaceCache = class {
         return resolved;
       }
       case "github": {
-        await mkdir2(dirname2(targetDir), { recursive: true });
+        await mkdir3(dirname2(targetDir), { recursive: true });
         const resolved = await cloneGithubMarketplace(
           source,
           targetDir,
@@ -2910,8 +3130,12 @@ var MarketplaceCache = class {
         await this.writeMeta(name, source);
         return resolved;
       }
+      case "rush": {
+        const resolved = await this.resolveRushMarketplace(source, name);
+        await this.writeMeta(name, source);
+        return resolved;
+      }
       case "git":
-      case "rush":
       case "npm":
         throw new NotImplementedError(source.kind, source.raw);
     }
@@ -2928,7 +3152,7 @@ var MarketplaceCache = class {
     if (!await pathExists2(target)) {
       return;
     }
-    await rm2(target, { recursive: true, force: true });
+    await rm3(target, { recursive: true, force: true });
   }
   /**
    * 重新 fetch 远端 source（仅对 github: / git: / rush:// / npm:）。
@@ -2957,8 +3181,12 @@ var MarketplaceCache = class {
         await this.writeMeta(name, meta.source);
         return resolved;
       }
+      case "rush": {
+        const resolved = await this.resolveRushMarketplace(meta.source, name);
+        await this.writeMeta(name, meta.source);
+        return resolved;
+      }
       case "git":
-      case "rush":
       case "npm":
         throw new NotImplementedError(meta.source.kind, meta.source.raw);
     }
@@ -2983,7 +3211,7 @@ var MarketplaceCache = class {
       if (!meta) continue;
       result.push({
         name: entry.name,
-        path: resolve6(this.cacheBaseDir, entry.name),
+        path: resolve7(this.cacheBaseDir, entry.name),
         source: meta.source,
         cachedAt: meta.cachedAt
       });
@@ -3026,14 +3254,43 @@ var MarketplaceCache = class {
         const manifest = await readMarketplaceJson(cacheDir);
         return { name, rootDir: cacheDir, source, manifest };
       }
+      case "rush": {
+        const cacheDir = this.pathFor(name);
+        const manifest = await readMarketplaceJson(cacheDir);
+        return { name, rootDir: cacheDir, source, manifest };
+      }
       case "git":
-      case "rush":
       case "npm":
         throw new NotImplementedError(source.kind, source.raw);
     }
   }
+  /**
+   * Fetch rush:// marketplace from API and write local marketplace.json.
+   *
+   * Called by `add()` and `update()` — writes/overwrites the local cache so
+   * that `resolveExisting()` (used by `get()`) can read purely from disk.
+   */
+  async resolveRushMarketplace(source, name) {
+    const token = getAuthToken();
+    const data = await fetchRushMarketplace(source, { token });
+    const manifest = {
+      name: data.name || "rush",
+      plugins: data.plugins.map((p) => ({
+        name: p.name,
+        version: p.version,
+        description: p.description,
+        source: `./plugins/${p.name}`
+      }))
+    };
+    const resolvedName = name ?? defaultNameFromSource(source);
+    const rootDir = this.pathFor(resolvedName);
+    const manifestDir = resolve7(rootDir, ".claude-plugin");
+    await mkdir3(manifestDir, { recursive: true });
+    await atomicWriteJson(resolve7(manifestDir, "marketplace.json"), manifest);
+    return { name: resolvedName, rootDir, source, manifest };
+  }
   metaPathFor(name) {
-    return resolve6(this.pathFor(name), CACHE_META_FILENAME);
+    return resolve7(this.pathFor(name), CACHE_META_FILENAME);
   }
   async readMeta(name) {
     const metaPath = this.metaPathFor(name);
@@ -3070,7 +3327,7 @@ var MarketplaceCache = class {
   }
   async writeMeta(name, source) {
     const metaPath = this.metaPathFor(name);
-    await mkdir2(dirname2(metaPath), { recursive: true });
+    await mkdir3(dirname2(metaPath), { recursive: true });
     const payload = {
       sourceRaw: source.raw,
       cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3091,12 +3348,12 @@ async function pathExists2(p) {
 async function atomicWriteJson(filePath, payload) {
   const content = `${JSON.stringify(payload, null, 2)}
 `;
-  const tmp = `${filePath}.${randomUUID()}.tmp`;
+  const tmp = `${filePath}.${randomUUID2()}.tmp`;
   try {
-    await writeFile2(tmp, content, { encoding: "utf8" });
-    await rename(tmp, filePath);
+    await writeFile3(tmp, content, { encoding: "utf8" });
+    await rename2(tmp, filePath);
   } catch (err) {
-    await rm2(tmp, { force: true }).catch(() => {
+    await rm3(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
@@ -3204,19 +3461,19 @@ function registerAddCommand(group, _root) {
 }
 
 // src/installers/registry.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { constants as fsConstants4 } from "fs";
 import {
   access as access4,
-  mkdir as mkdir3,
+  mkdir as mkdir4,
   readFile as readFile4,
-  rename as rename2,
-  rm as rm3,
-  stat,
-  writeFile as writeFile3
+  rename as rename3,
+  rm as rm4,
+  stat as stat2,
+  writeFile as writeFile4
 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname3, resolve as resolve7 } from "path";
+import { dirname as dirname3, resolve as resolve8 } from "path";
 var REGISTRY_RELATIVE_PATH = ".rush/plugins/registry.json";
 var REGISTRY_SCHEMA_VERSION = 1;
 var RushRegistryError = class extends Error {
@@ -3305,13 +3562,13 @@ async function pathExists3(p) {
   }
 }
 async function atomicWrite(filePath, content) {
-  await mkdir3(dirname3(filePath), { recursive: true });
-  const tmp = `${filePath}.${randomUUID2()}.tmp`;
+  await mkdir4(dirname3(filePath), { recursive: true });
+  const tmp = `${filePath}.${randomUUID3()}.tmp`;
   try {
-    await writeFile3(tmp, content, { encoding: "utf8", flag: "w" });
-    await rename2(tmp, filePath);
+    await writeFile4(tmp, content, { encoding: "utf8", flag: "w" });
+    await rename3(tmp, filePath);
   } catch (err) {
-    await rm3(tmp, { force: true }).catch(() => {
+    await rm4(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
@@ -3323,7 +3580,7 @@ async function loadFromPath(filePath) {
       mtimeMs: null
     };
   }
-  const stats = await stat(filePath);
+  const stats = await stat2(filePath);
   const raw = await readFile4(filePath, "utf8");
   let parsed;
   try {
@@ -3373,7 +3630,7 @@ var RushRegistryStore = class _RushRegistryStore {
    */
   static resolvePath(opts) {
     const home = opts?.home ?? homedir4();
-    return resolve7(home, REGISTRY_RELATIVE_PATH);
+    return resolve8(home, REGISTRY_RELATIVE_PATH);
   }
   /**
    * 读取 registry 文件。
@@ -3432,12 +3689,12 @@ var RushRegistryStore = class _RushRegistryStore {
         throw new RushRegistryConflictError(this.filePath);
       }
       await atomicWrite(this.filePath, this.serialize());
-      const stats2 = await stat(this.filePath);
+      const stats2 = await stat2(this.filePath);
       this.loadedMtimeMs = stats2.mtimeMs;
       this.deletedPluginKeys.clear();
       return;
     }
-    const stats = await stat(this.filePath).catch(() => null);
+    const stats = await stat2(this.filePath).catch(() => null);
     if (stats === null) {
       if (attempt === 0) {
         await this.reloadAndMerge();
@@ -3453,7 +3710,7 @@ var RushRegistryStore = class _RushRegistryStore {
       throw new RushRegistryConflictError(this.filePath);
     }
     await atomicWrite(this.filePath, this.serialize());
-    const afterStats = await stat(this.filePath);
+    const afterStats = await stat2(this.filePath);
     this.loadedMtimeMs = afterStats.mtimeMs;
     this.deletedPluginKeys.clear();
   }
@@ -3940,7 +4197,7 @@ function registerMcpCommand(program) {
     "Set credential values (e.g. --set TOKEN=xxx KEY=yyy)"
   ).action(async (mcpId, opts) => {
     const format = resolveFormat(program.opts());
-    const { runMcpInstall, printMcpInstallSummary } = await import("./install-RTV2VWCC.js");
+    const { runMcpInstall, printMcpInstallSummary } = await import("./install-KY7BF54H.js");
     let setValues;
     if (opts.set) {
       setValues = {};
@@ -4001,7 +4258,7 @@ function registerMcpCommand(program) {
     "Comma-separated targets: claude-desktop,claude-code (default: both)"
   ).action(async (mcpId, opts) => {
     const format = resolveFormat(program.opts());
-    const { runMcpUninstall, printMcpUninstallSummary } = await import("./install-RTV2VWCC.js");
+    const { runMcpUninstall, printMcpUninstallSummary } = await import("./install-KY7BF54H.js");
     try {
       const result = await runMcpUninstall({
         mcpId,
@@ -4033,26 +4290,29 @@ function registerMcpCommand(program) {
   });
 }
 
+// src/commands/plugin/install.ts
+import { resolve as resolve20 } from "path";
+
 // src/installers/claude-code/installer.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import {
   copyFile,
   lstat,
-  mkdir as mkdir4,
+  mkdir as mkdir5,
   readdir as readdir2,
   readFile as readFile5,
   readlink,
-  rename as rename3,
-  rm as rm4,
-  stat as stat2,
+  rename as rename4,
+  rm as rm5,
+  stat as stat3,
   symlink,
   unlink
 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname4, join as join9, resolve as resolve9 } from "path";
+import { dirname as dirname4, join as join9, resolve as resolve10 } from "path";
 
 // src/installers/claude-code/mcp.ts
-import { execFileSync as execFileSync4 } from "child_process";
+import { execFileSync as execFileSync5 } from "child_process";
 import { isAbsolute as isAbsolute2 } from "path";
 var RUSH_AI_PLUGIN_NAME = "rush";
 var RUSH_AI_MARKETPLACE_NAME = "rush-marketplace";
@@ -4088,7 +4348,7 @@ function normalizeClaudeMcpServers(ref, manifest, resolver = defaultRushBinaryRe
 }
 function defaultRushBinaryResolver() {
   try {
-    const result = execFileSync4("which", ["rush-ai"], {
+    const result = execFileSync5("which", ["rush-ai"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
@@ -4101,7 +4361,7 @@ function defaultRushBinaryResolver() {
 }
 
 // src/installers/claude-code/paths.ts
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 var CLAUDE_DIR = ".claude";
 var PLUGINS_SUBDIR = "plugins";
 var CACHE_SUBDIR = "cache";
@@ -4119,27 +4379,27 @@ var ClaudeCodePaths = class {
   }
   /** `<home>/.claude/` */
   get claudeDir() {
-    return resolve8(this.home, CLAUDE_DIR);
+    return resolve9(this.home, CLAUDE_DIR);
   }
   /** `<home>/.claude/settings.json` */
   get settingsJson() {
-    return resolve8(this.claudeDir, "settings.json");
+    return resolve9(this.claudeDir, "settings.json");
   }
   /** `<home>/.claude/plugins/` */
   get pluginsDir() {
-    return resolve8(this.claudeDir, PLUGINS_SUBDIR);
+    return resolve9(this.claudeDir, PLUGINS_SUBDIR);
   }
   /** `<home>/.claude/plugins/known_marketplaces.json` */
   get knownMarketplacesJson() {
-    return resolve8(this.pluginsDir, "known_marketplaces.json");
+    return resolve9(this.pluginsDir, "known_marketplaces.json");
   }
   /** `<home>/.claude/plugins/installed_plugins.json` */
   get installedPluginsJson() {
-    return resolve8(this.pluginsDir, "installed_plugins.json");
+    return resolve9(this.pluginsDir, "installed_plugins.json");
   }
   /** `<home>/.claude/plugins/cache/` */
   get cacheDir() {
-    return resolve8(this.pluginsDir, CACHE_SUBDIR);
+    return resolve9(this.pluginsDir, CACHE_SUBDIR);
   }
   /**
    * `<home>/.claude/plugins/marketplaces/`。
@@ -4149,34 +4409,34 @@ var ClaudeCodePaths = class {
    * Claude Code 会识别不到 plugin 条目（regression fix，bug #4）。
    */
   get marketplacesRootDir() {
-    return resolve8(this.pluginsDir, "marketplaces");
+    return resolve9(this.pluginsDir, "marketplaces");
   }
   /** `<home>/.claude/plugins/marketplaces/<mkt>/` */
   marketplaceInstallDir(marketplace) {
-    return resolve8(this.marketplacesRootDir, marketplace);
+    return resolve9(this.marketplacesRootDir, marketplace);
   }
   /** `<home>/.claude/plugins/cache/<mkt>/` */
   marketplaceCacheDir(marketplace) {
-    return resolve8(this.cacheDir, marketplace);
+    return resolve9(this.cacheDir, marketplace);
   }
   /** `<home>/.claude/plugins/cache/<mkt>/<plugin>/` */
   pluginCacheDir(ref) {
-    return resolve8(this.marketplaceCacheDir(ref.marketplace), ref.name);
+    return resolve9(this.marketplaceCacheDir(ref.marketplace), ref.name);
   }
   /** `<home>/.claude/plugins/cache/<mkt>/<plugin>/<version>/` */
   pluginVersionDir(ref, version) {
-    return resolve8(this.pluginCacheDir(ref), version);
+    return resolve9(this.pluginCacheDir(ref), version);
   }
   /** `<home>/.claude/plugins/cache/<mkt>/<plugin>/<version>/.claude-plugin/plugin.json` */
   pluginManifestPath(ref, version) {
-    return resolve8(
+    return resolve9(
       this.pluginVersionDir(ref, version),
       PLUGIN_MANIFEST_RELATIVE
     );
   }
   /** `<home>/.claude/plugins/cache/<mkt>/<plugin>/<version>/<capability>/` */
   capabilityDir(ref, version, capability) {
-    return resolve8(this.pluginVersionDir(ref, version), capability);
+    return resolve9(this.pluginVersionDir(ref, version), capability);
   }
 };
 function pluginKey(ref) {
@@ -4290,13 +4550,13 @@ var ClaudeCodeInstaller = class {
     }
     try {
       const writtenFiles = [];
-      await mkdir4(pluginVersionDir, { recursive: true });
+      await mkdir5(pluginVersionDir, { recursive: true });
       writtenFiles.push(pluginVersionDir);
       for (const cap of CAPABILITY_DIRS) {
-        const srcDir = resolve9(plugin.sourceDir, cap);
+        const srcDir = resolve10(plugin.sourceDir, cap);
         if (!await dirExists(srcDir)) continue;
         const dstDir = this.paths.capabilityDir(ref, version, cap);
-        await mkdir4(dstDir, { recursive: true });
+        await mkdir5(dstDir, { recursive: true });
         writtenFiles.push(dstDir);
         const copied = await copyDirTracked(srcDir, dstDir);
         writtenFiles.push(...copied);
@@ -4432,7 +4692,7 @@ var ClaudeCodeInstaller = class {
       files.push(mktDir);
     } else if (kind === "dir") {
       if (await pathExists(join9(mktDir, ".rush-marketplace-source.json"))) {
-        await rm4(mktDir, { recursive: true, force: true });
+        await rm5(mktDir, { recursive: true, force: true });
         files.push(mktDir);
       }
     }
@@ -4503,12 +4763,12 @@ var ClaudeCodeInstaller = class {
       return { written: false, path: "" };
     }
     const mktDir = this.paths.marketplaceInstallDir(marketplaceName);
-    await mkdir4(this.paths.marketplacesRootDir, { recursive: true });
+    await mkdir5(this.paths.marketplacesRootDir, { recursive: true });
     const kind = await inodeKind(mktDir);
     if (kind === "symlink") {
       const target = await readlink(mktDir).catch(() => null);
-      const resolvedTarget = target !== null ? resolve9(dirname4(mktDir), target) : null;
-      if (resolvedTarget && resolvedTarget === resolve9(src.rootDir)) {
+      const resolvedTarget = target !== null ? resolve10(dirname4(mktDir), target) : null;
+      if (resolvedTarget && resolvedTarget === resolve10(src.rootDir)) {
         return { written: false, path: mktDir };
       }
       throw new Error(
@@ -4541,7 +4801,7 @@ var ClaudeCodeInstaller = class {
       return { written: true, path: mktDir };
     }
     await copyDirTracked(src.rootDir, mktDir).catch(async (err) => {
-      await rm4(mktDir, { recursive: true, force: true }).catch(() => {
+      await rm5(mktDir, { recursive: true, force: true }).catch(() => {
       });
       throw err;
     });
@@ -4577,7 +4837,7 @@ var ClaudeCodeInstaller = class {
     const pluginVersionDir = this.paths.pluginVersionDir(ref, version);
     const dryFiles = [pluginVersionDir];
     for (const cap of CAPABILITY_DIRS) {
-      const srcDir = resolve9(plugin.sourceDir, cap);
+      const srcDir = resolve10(plugin.sourceDir, cap);
       if (!await dirExists(srcDir)) continue;
       const dstDir = this.paths.capabilityDir(ref, version, cap);
       dryFiles.push(dstDir);
@@ -4697,8 +4957,8 @@ var ClaudeCodeInstaller = class {
     const settings = await this.readRawJsonForRollback(this.paths.settingsJson);
     let backupVersionDir = null;
     if (preexistedVersion === "dir") {
-      backupVersionDir = `${pluginVersionDir}.rollback-${randomUUID3()}`;
-      await rename3(pluginVersionDir, backupVersionDir);
+      backupVersionDir = `${pluginVersionDir}.rollback-${randomUUID4()}`;
+      await rename4(pluginVersionDir, backupVersionDir);
     }
     return {
       ref,
@@ -4719,7 +4979,7 @@ var ClaudeCodeInstaller = class {
    */
   async finalizeRollback(snap) {
     if (snap.backupVersionDir) {
-      await rm4(snap.backupVersionDir, { recursive: true, force: true });
+      await rm5(snap.backupVersionDir, { recursive: true, force: true });
     }
   }
   /**
@@ -4732,19 +4992,19 @@ var ClaudeCodeInstaller = class {
    */
   async applyRollback(snap) {
     if (snap.preexistedVersion === "dir" && snap.backupVersionDir) {
-      await rm4(snap.pluginVersionDir, { recursive: true, force: true });
-      await rename3(snap.backupVersionDir, snap.pluginVersionDir);
+      await rm5(snap.pluginVersionDir, { recursive: true, force: true });
+      await rename4(snap.backupVersionDir, snap.pluginVersionDir);
     } else if (snap.preexistedVersion === "missing") {
-      await rm4(snap.pluginVersionDir, { recursive: true, force: true });
+      await rm5(snap.pluginVersionDir, { recursive: true, force: true });
     }
     if (snap.preexistedPlugin === "missing") {
-      await rm4(this.paths.pluginCacheDir(snap.ref), {
+      await rm5(this.paths.pluginCacheDir(snap.ref), {
         recursive: true,
         force: true
       });
     }
     if (snap.preexistedMarketplace === "missing") {
-      await rm4(this.paths.marketplaceCacheDir(snap.ref.marketplace), {
+      await rm5(this.paths.marketplaceCacheDir(snap.ref.marketplace), {
         recursive: true,
         force: true
       });
@@ -4758,7 +5018,7 @@ var ClaudeCodeInstaller = class {
         await unlink(mktInstallDir).catch(() => {
         });
       } else if (currentKind !== "missing") {
-        await rm4(mktInstallDir, { recursive: true, force: true }).catch(
+        await rm5(mktInstallDir, { recursive: true, force: true }).catch(
           () => {
           }
         );
@@ -4781,7 +5041,7 @@ var ClaudeCodeInstaller = class {
   async restoreRawJson(path4, state) {
     if (!state.existed) {
       if (await pathExists(path4)) {
-        await rm4(path4, { force: true });
+        await rm5(path4, { force: true });
       }
       return;
     }
@@ -5116,7 +5376,7 @@ async function defaultSymlinkRunner(target, linkPath) {
 }
 async function dirExists(p) {
   try {
-    const s = await stat2(p);
+    const s = await stat3(p);
     return s.isDirectory();
   } catch {
     return false;
@@ -5156,12 +5416,12 @@ async function copyDirTracked(srcDir, dstDir) {
     const srcPath = join9(srcDir, entry.name);
     const dstPath = join9(dstDir, entry.name);
     if (entry.isDirectory()) {
-      await mkdir4(dstPath, { recursive: true });
+      await mkdir5(dstPath, { recursive: true });
       written.push(dstPath);
       const subWritten = await copyDirTracked(srcPath, dstPath);
       written.push(...subWritten);
     } else if (entry.isFile()) {
-      await mkdir4(dirname4(dstPath), { recursive: true });
+      await mkdir5(dirname4(dstPath), { recursive: true });
       await copyFile(srcPath, dstPath);
       written.push(dstPath);
     }
@@ -5172,7 +5432,7 @@ async function writeAtomicWithMtimeCheck(filePath, data, expectedMtimeMs) {
   if (expectedMtimeMs !== null) {
     let currentMtime = null;
     try {
-      const s = await stat2(filePath);
+      const s = await stat3(filePath);
       currentMtime = s.mtimeMs;
     } catch {
       currentMtime = null;
@@ -5199,14 +5459,14 @@ import { constants as fsConstants6 } from "fs";
 import {
   access as access6,
   cp,
-  mkdir as mkdir6,
+  mkdir as mkdir7,
   mkdtemp,
   readdir as readdir3,
   readFile as readFile7,
-  rename as rename5,
-  rm as rm6,
-  stat as stat4,
-  writeFile as writeFile5
+  rename as rename6,
+  rm as rm7,
+  stat as stat5,
+  writeFile as writeFile6
 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import {
@@ -5214,7 +5474,7 @@ import {
   dirname as dirname6,
   extname,
   relative as pathRelative,
-  resolve as resolve10
+  resolve as resolve11
 } from "path";
 
 // src/installers/codex/mcp.ts
@@ -5318,17 +5578,17 @@ function pluginSectionKey(ref) {
 }
 
 // src/installers/codex/toml.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { constants as fsConstants5 } from "fs";
 import {
   access as access5,
   copyFile as copyFile2,
-  mkdir as mkdir5,
+  mkdir as mkdir6,
   readFile as readFile6,
-  rename as rename4,
-  rm as rm5,
-  stat as stat3,
-  writeFile as writeFile4
+  rename as rename5,
+  rm as rm6,
+  stat as stat4,
+  writeFile as writeFile5
 } from "fs/promises";
 import { dirname as dirname5 } from "path";
 import tomlModule from "@iarna/toml";
@@ -5364,7 +5624,7 @@ async function readCodexConfig(filePath) {
   if (!await pathExists4(filePath)) {
     return { data: {}, mtimeMs: null };
   }
-  const stats = await stat3(filePath);
+  const stats = await stat4(filePath);
   const raw = await readFile6(filePath, "utf8");
   try {
     const parsed = tomlParse(raw);
@@ -5379,7 +5639,7 @@ async function backupCodexConfig(filePath, backupPath) {
   }
   let finalBackup = backupPath;
   if (await pathExists4(finalBackup)) {
-    finalBackup = `${backupPath}.${randomUUID4().slice(0, 8)}`;
+    finalBackup = `${backupPath}.${randomUUID5().slice(0, 8)}`;
   }
   await copyFile2(filePath, finalBackup);
   return finalBackup;
@@ -5388,19 +5648,19 @@ async function writeCodexConfig(filePath, data, expectedMtimeMs) {
   await assertNoMtimeDrift(filePath, expectedMtimeMs);
   const serialized = tomlStringify(data);
   await atomicWrite2(filePath, serialized);
-  const afterStats = await stat3(filePath);
+  const afterStats = await stat4(filePath);
   return { mtimeMs: afterStats.mtimeMs };
 }
 async function restoreCodexConfigFromBackup(filePath, backupPath) {
   if (!backupPath || !await pathExists4(backupPath)) {
     if (await pathExists4(filePath)) {
-      await rm5(filePath, { force: true });
+      await rm6(filePath, { force: true });
     }
     return;
   }
   const raw = await readFile6(backupPath, "utf8");
   await atomicWrite2(filePath, raw);
-  await rm5(backupPath, { force: true }).catch(() => {
+  await rm6(backupPath, { force: true }).catch(() => {
   });
 }
 function setMarketplaceSection(config, name, entry) {
@@ -5446,13 +5706,13 @@ async function pathExists4(p) {
   }
 }
 async function atomicWrite2(filePath, content) {
-  await mkdir5(dirname5(filePath), { recursive: true });
-  const tmp = `${filePath}.${randomUUID4()}.tmp`;
+  await mkdir6(dirname5(filePath), { recursive: true });
+  const tmp = `${filePath}.${randomUUID5()}.tmp`;
   try {
-    await writeFile4(tmp, content, { encoding: "utf8", flag: "w" });
-    await rename4(tmp, filePath);
+    await writeFile5(tmp, content, { encoding: "utf8", flag: "w" });
+    await rename5(tmp, filePath);
   } catch (err) {
-    await rm5(tmp, { force: true }).catch(() => {
+    await rm6(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
@@ -5464,7 +5724,7 @@ async function assertNoMtimeDrift(filePath, expectedMtimeMs) {
     }
     return;
   }
-  const current = await stat3(filePath).catch(() => null);
+  const current = await stat4(filePath).catch(() => null);
   if (current === null) {
     throw new CodexConfigTomlConflictError(filePath);
   }
@@ -5718,9 +5978,9 @@ var CodexInstaller = class {
     const cfgPath = codexConfigTomlPath(this.home);
     const preExisted = await pathExists5(versionDir);
     if (preExisted) {
-      await rm6(versionDir, { recursive: true, force: true });
+      await rm7(versionDir, { recursive: true, force: true });
     }
-    await mkdir6(versionDir, { recursive: true });
+    await mkdir7(versionDir, { recursive: true });
     rollback.createdVersionDir = versionDir;
     const dstSkills = codexPluginSkillsDir(versionDir);
     const writtenFiles = [versionDir];
@@ -5855,10 +6115,10 @@ var CodexInstaller = class {
     const srcMcp = plugin.manifest.mcpServers;
     if (srcMcp !== void 0 && srcMcp !== null) {
       if (typeof srcMcp === "string") {
-        const destPath = resolve10(versionDir, srcMcp);
+        const destPath = resolve11(versionDir, srcMcp);
         files.push(destPath);
-        const srcPath = resolve10(plugin.sourceDir, srcMcp);
-        const rel = pathRelative(resolve10(plugin.sourceDir), srcPath);
+        const srcPath = resolve11(plugin.sourceDir, srcMcp);
+        const rel = pathRelative(resolve11(plugin.sourceDir), srcPath);
         const traversal = rel === ".." || rel.startsWith("..") || rel.startsWith("/");
         const exists = await pathExists5(srcPath);
         if (traversal || !exists) {
@@ -5954,18 +6214,18 @@ async function rollbackInstall(home, rollback) {
       }
     );
   } else if (rollback.preExistingConfig === false) {
-    await rm6(cfgPath, { force: true }).catch(() => {
+    await rm7(cfgPath, { force: true }).catch(() => {
     });
   }
   if (rollback.createdVersionDir) {
-    await rm6(rollback.createdVersionDir, {
+    await rm7(rollback.createdVersionDir, {
       recursive: true,
       force: true
     }).catch(() => {
     });
   }
   if (rollback.createdMarketplacePluginDir) {
-    await rm6(rollback.createdMarketplacePluginDir, {
+    await rm7(rollback.createdMarketplacePluginDir, {
       recursive: true,
       force: true
     }).catch(() => {
@@ -6003,14 +6263,14 @@ function assertSafePathComponents(ref, version) {
 }
 async function copyAuthorProvidedMcp(sourceDir, versionDir, relativeRef) {
   if (typeof relativeRef !== "string" || relativeRef.length === 0) return null;
-  const srcPath = resolve10(sourceDir, relativeRef);
-  const rel = pathRelative(resolve10(sourceDir), srcPath);
+  const srcPath = resolve11(sourceDir, relativeRef);
+  const rel = pathRelative(resolve11(sourceDir), srcPath);
   if (rel === ".." || rel.startsWith("..") || rel.startsWith("/")) {
     return null;
   }
   if (!await pathExists5(srcPath)) return null;
-  const destPath = resolve10(versionDir, relativeRef);
-  await mkdir6(dirname6(destPath), { recursive: true });
+  const destPath = resolve11(versionDir, relativeRef);
+  await mkdir7(dirname6(destPath), { recursive: true });
   const raw = await readFile7(srcPath, "utf8");
   await writeFileAtomic(destPath, raw);
   let mcpKeys = [];
@@ -6027,18 +6287,18 @@ async function copyAuthorProvidedMcp(sourceDir, versionDir, relativeRef) {
 async function writeCodexMarketplaceMirror(input) {
   const pluginParent = dirname6(input.pluginDir);
   const pluginBase = basename2(input.pluginDir);
-  await mkdir6(pluginParent, { recursive: true });
+  await mkdir7(pluginParent, { recursive: true });
   const tmpPluginDir = await mkdtemp(
-    resolve10(pluginParent, `.${pluginBase}.tmp-`)
+    resolve11(pluginParent, `.${pluginBase}.tmp-`)
   );
   const backupPluginDir = await mkdtemp(
-    resolve10(pluginParent, `.${pluginBase}.bak-`)
+    resolve11(pluginParent, `.${pluginBase}.bak-`)
   );
   let hadExistingPluginDir = false;
   let swappedPluginDir = false;
   try {
-    await rm6(tmpPluginDir, { recursive: true, force: true });
-    await rm6(backupPluginDir, { recursive: true, force: true }).catch(() => {
+    await rm7(tmpPluginDir, { recursive: true, force: true });
+    await rm7(backupPluginDir, { recursive: true, force: true }).catch(() => {
     });
     await cp(input.versionDir, tmpPluginDir, {
       recursive: true,
@@ -6048,16 +6308,16 @@ async function writeCodexMarketplaceMirror(input) {
     });
     hadExistingPluginDir = await pathExists5(input.pluginDir);
     if (hadExistingPluginDir) {
-      await rename5(input.pluginDir, backupPluginDir);
+      await rename6(input.pluginDir, backupPluginDir);
     }
-    await rename5(tmpPluginDir, input.pluginDir);
+    await rename6(tmpPluginDir, input.pluginDir);
     swappedPluginDir = true;
     await upsertCodexMarketplaceManifest(input.marketplaceDir, input.plugin);
     if (hadExistingPluginDir) {
-      await rm6(backupPluginDir, { recursive: true, force: true });
+      await rm7(backupPluginDir, { recursive: true, force: true });
     }
   } catch (err) {
-    await rm6(tmpPluginDir, { recursive: true, force: true }).catch(() => {
+    await rm7(tmpPluginDir, { recursive: true, force: true }).catch(() => {
     });
     let restoredBackup = false;
     if (hadExistingPluginDir && await pathExists5(backupPluginDir)) {
@@ -6065,33 +6325,33 @@ async function writeCodexMarketplaceMirror(input) {
       try {
         if (await pathExists5(input.pluginDir)) {
           displacedPluginDir = await mkdtemp(
-            resolve10(pluginParent, `.${pluginBase}.failed-`)
+            resolve11(pluginParent, `.${pluginBase}.failed-`)
           );
-          await rm6(displacedPluginDir, { recursive: true, force: true });
-          await rename5(input.pluginDir, displacedPluginDir);
+          await rm7(displacedPluginDir, { recursive: true, force: true });
+          await rename6(input.pluginDir, displacedPluginDir);
         }
-        await rename5(backupPluginDir, input.pluginDir);
+        await rename6(backupPluginDir, input.pluginDir);
         restoredBackup = true;
         if (displacedPluginDir) {
-          await rm6(displacedPluginDir, { recursive: true, force: true }).catch(
+          await rm7(displacedPluginDir, { recursive: true, force: true }).catch(
             () => {
             }
           );
         }
       } catch {
         if (displacedPluginDir && !await pathExists5(input.pluginDir) && await pathExists5(displacedPluginDir)) {
-          await rename5(displacedPluginDir, input.pluginDir).catch(() => {
+          await rename6(displacedPluginDir, input.pluginDir).catch(() => {
           });
         }
       }
     } else if (swappedPluginDir) {
-      await rm6(input.pluginDir, { recursive: true, force: true }).catch(
+      await rm7(input.pluginDir, { recursive: true, force: true }).catch(
         () => {
         }
       );
     }
     if (restoredBackup || !hadExistingPluginDir) {
-      await rm6(backupPluginDir, { recursive: true, force: true }).catch(
+      await rm7(backupPluginDir, { recursive: true, force: true }).catch(
         () => {
         }
       );
@@ -6152,7 +6412,7 @@ async function planCodexSkills(plugin) {
   const usedNames = /* @__PURE__ */ new Set();
   const coveredAliases = /* @__PURE__ */ new Set();
   const commandFiles = await listMarkdownFiles(
-    resolve10(plugin.sourceDir, "commands"),
+    resolve11(plugin.sourceDir, "commands"),
     {
       recursive: false
     }
@@ -6162,19 +6422,19 @@ async function planCodexSkills(plugin) {
       commandFiles.map((file2) => markdownSkillAlias(plugin.manifest.name, file2))
     )
   );
-  const nativeSkillsDir = resolve10(plugin.sourceDir, "skills");
+  const nativeSkillsDir = resolve11(plugin.sourceDir, "skills");
   if (await hasCodexSkillDir(nativeSkillsDir)) {
     for (const name of await listCodexSkillNames(nativeSkillsDir)) {
       usedNames.add(name);
       coveredAliases.add(skillAlias(plugin.manifest.name, name));
       sources.push({
         kind: "copy-skill",
-        sourceDir: resolve10(nativeSkillsDir, name),
+        sourceDir: resolve11(nativeSkillsDir, name),
         skillName: name
       });
     }
   } else {
-    const dotSkillsDir = resolve10(plugin.sourceDir, ".skills");
+    const dotSkillsDir = resolve11(plugin.sourceDir, ".skills");
     const claudeSkills = await listMarkdownFiles(dotSkillsDir);
     const claudeAliases = /* @__PURE__ */ new Map();
     for (const file2 of claudeSkills) {
@@ -6213,7 +6473,7 @@ async function planCodexSkills(plugin) {
 async function materializeCodexSkills(plan, dstSkills) {
   for (const source of plan.sources) {
     if (source.kind === "copy-skill") {
-      await cp(source.sourceDir, resolve10(dstSkills, source.skillName), {
+      await cp(source.sourceDir, resolve11(dstSkills, source.skillName), {
         recursive: true,
         dereference: false,
         preserveTimestamps: true,
@@ -6224,7 +6484,7 @@ async function materializeCodexSkills(plan, dstSkills) {
     const raw = await readFile7(source.sourceFile, "utf8");
     const normalized = normalizeSkillMarkdown(raw, source.skillName);
     await writeFileAtomic(
-      resolve10(dstSkills, source.skillName, "SKILL.md"),
+      resolve11(dstSkills, source.skillName, "SKILL.md"),
       normalized
     );
   }
@@ -6310,7 +6570,7 @@ async function listCodexSkillNames(skillsDir) {
   const names = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    if (await pathExists5(resolve10(skillsDir, entry.name, "SKILL.md"))) {
+    if (await pathExists5(resolve11(skillsDir, entry.name, "SKILL.md"))) {
       names.push(entry.name);
     }
   }
@@ -6328,7 +6588,7 @@ async function listMarkdownFiles(dir, opts = {}) {
       return;
     }
     for (const entry of entries) {
-      const abs = resolve10(current, entry.name);
+      const abs = resolve11(current, entry.name);
       if (entry.isDirectory()) {
         if (recursive) await walk2(abs);
         continue;
@@ -6383,14 +6643,14 @@ function slugify(value) {
   return slug.length > 0 ? slug : "skill";
 }
 async function writeFileAtomic(filePath, content) {
-  await mkdir6(dirname6(filePath), { recursive: true });
+  await mkdir7(dirname6(filePath), { recursive: true });
   const tmp = `${filePath}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await writeFile5(tmp, content, { encoding: "utf8", flag: "w" });
-    const { rename: rename8 } = await import("fs/promises");
-    await rename8(tmp, filePath);
+    await writeFile6(tmp, content, { encoding: "utf8", flag: "w" });
+    const { rename: rename9 } = await import("fs/promises");
+    await rename9(tmp, filePath);
   } catch (err) {
-    await rm6(tmp, { force: true }).catch(() => {
+    await rm7(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
@@ -6405,7 +6665,7 @@ async function pathExists5(p) {
 }
 async function isDir(p) {
   try {
-    const s = await stat4(p);
+    const s = await stat5(p);
     return s.isDirectory();
   } catch {
     return false;
@@ -6420,7 +6680,7 @@ function parsePluginKey2(key) {
   return { name: key.slice(0, at), marketplace: key.slice(at + 1) };
 }
 async function detectInstalledVersion(home, ref) {
-  const baseDir = resolve10(
+  const baseDir = resolve11(
     codexHomeDir(home),
     "plugins",
     "cache",
@@ -6436,14 +6696,14 @@ async function detectInstalledVersion(home, ref) {
   }
   let best = null;
   for (const entry of entries) {
-    const versionDir = resolve10(baseDir, entry);
-    const manifestPath = resolve10(versionDir, ".codex-plugin", "plugin.json");
+    const versionDir = resolve11(baseDir, entry);
+    const manifestPath = resolve11(versionDir, ".codex-plugin", "plugin.json");
     if (!await pathExists5(manifestPath)) continue;
     try {
       const raw = await readFile7(manifestPath, "utf8");
       const obj = JSON.parse(raw);
       const version = typeof obj.version === "string" && obj.version.length > 0 ? obj.version : entry;
-      const s = await stat4(versionDir);
+      const s = await stat5(versionDir);
       if (!best || s.mtimeMs > best.mtimeMs) {
         best = { version, mtimeMs: s.mtimeMs };
       }
@@ -6465,20 +6725,20 @@ function defaultRushAiBinaryResolver() {
 }
 
 // src/installers/cursor/installer.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import { constants as fsConstants8 } from "fs";
 import {
   access as access8,
   cp as cp2,
-  mkdir as mkdir8,
+  mkdir as mkdir9,
   readFile as readFile10,
-  rename as rename7,
-  rm as rm8,
-  stat as stat6,
-  writeFile as writeFile7
+  rename as rename8,
+  rm as rm9,
+  stat as stat7,
+  writeFile as writeFile8
 } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname8, relative, resolve as resolve13 } from "path";
+import { dirname as dirname8, relative, resolve as resolve14 } from "path";
 
 // src/installers/cursor/marker.ts
 var RUSH_AI_MARKER = "<!-- rush-ai:auto-generated -->";
@@ -6487,16 +6747,16 @@ function hasRushAiMarker(fileContent) {
 }
 
 // src/installers/cursor/mcp.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 import { constants as fsConstants7 } from "fs";
 import {
   access as access7,
-  mkdir as mkdir7,
+  mkdir as mkdir8,
   readFile as readFile8,
-  rename as rename6,
-  rm as rm7,
-  stat as stat5,
-  writeFile as writeFile6
+  rename as rename7,
+  rm as rm8,
+  stat as stat6,
+  writeFile as writeFile7
 } from "fs/promises";
 import { dirname as dirname7 } from "path";
 async function readCursorMcpJson(filePath) {
@@ -6506,7 +6766,7 @@ async function readCursorMcpJsonWithMtime(filePath) {
   if (!await pathExists6(filePath)) {
     return { data: {}, mtimeMs: null };
   }
-  const stats = await stat5(filePath);
+  const stats = await stat6(filePath);
   const raw = await readFile8(filePath, "utf8");
   let parsed;
   try {
@@ -6574,15 +6834,15 @@ function removeMcpServers(current, keysToRemove) {
   return cloned;
 }
 async function writeCursorMcpJson(filePath, data) {
-  await mkdir7(dirname7(filePath), { recursive: true });
+  await mkdir8(dirname7(filePath), { recursive: true });
   const content = `${JSON.stringify(data, null, 2)}
 `;
-  const tmp = `${filePath}.${randomUUID5()}.tmp`;
+  const tmp = `${filePath}.${randomUUID6()}.tmp`;
   try {
-    await writeFile6(tmp, content, { encoding: "utf8", flag: "w" });
-    await rename6(tmp, filePath);
+    await writeFile7(tmp, content, { encoding: "utf8", flag: "w" });
+    await rename7(tmp, filePath);
   } catch (err) {
-    await rm7(tmp, { force: true }).catch(() => {
+    await rm8(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
@@ -6597,25 +6857,25 @@ async function pathExists6(p) {
 }
 
 // src/installers/cursor/paths.ts
-import { resolve as resolve11 } from "path";
+import { resolve as resolve12 } from "path";
 var CURSOR_RELATIVE_DIR = ".cursor";
 function cursorDir(home) {
-  return resolve11(home, CURSOR_RELATIVE_DIR);
+  return resolve12(home, CURSOR_RELATIVE_DIR);
 }
 function cursorMcpJsonPath(home) {
-  return resolve11(cursorDir(home), "mcp.json");
+  return resolve12(cursorDir(home), "mcp.json");
 }
 function cursorRulesDir(home) {
-  return resolve11(cursorDir(home), "rules");
+  return resolve12(cursorDir(home), "rules");
 }
 function cursorRuleMdcPath(home, ruleName) {
-  return resolve11(cursorRulesDir(home), `${ruleName}.mdc`);
+  return resolve12(cursorRulesDir(home), `${ruleName}.mdc`);
 }
 function cursorSkillsDir(home) {
-  return resolve11(cursorDir(home), "skills");
+  return resolve12(cursorDir(home), "skills");
 }
 function cursorSkillDir(home, skillName) {
-  return resolve11(cursorSkillsDir(home), skillName);
+  return resolve12(cursorSkillsDir(home), skillName);
 }
 function bridgeSkillFileReference(skillName) {
   return `.cursor/skills/${skillName}/SKILL.md`;
@@ -6726,9 +6986,9 @@ function quoteIfNeeded(value) {
 
 // src/installers/cursor/skills.ts
 import { readFile as readFile9 } from "fs/promises";
-import { resolve as resolve12 } from "path";
+import { resolve as resolve13 } from "path";
 async function readSkillDescription(skillSourceDir) {
-  const skillMdPath = resolve12(skillSourceDir, "SKILL.md");
+  const skillMdPath = resolve13(skillSourceDir, "SKILL.md");
   let raw;
   try {
     raw = await readFile9(skillMdPath, "utf8");
@@ -6761,11 +7021,11 @@ async function executeRollback(ledger) {
       if (entry.kind === "restore-file") {
         await atomicWriteFile(entry.path, entry.originalContent);
       } else if (entry.kind === "remove-file") {
-        await rm8(entry.path, { force: true });
+        await rm9(entry.path, { force: true });
       } else if (entry.kind === "remove-dir") {
-        await rm8(entry.path, { recursive: true, force: true });
+        await rm9(entry.path, { recursive: true, force: true });
       } else {
-        await rm8(entry.path, { recursive: true, force: true });
+        await rm9(entry.path, { recursive: true, force: true });
         await safeRename(entry.backupPath, entry.path);
       }
     } catch (err) {
@@ -6777,20 +7037,20 @@ async function executeRollback(ledger) {
   return errors;
 }
 async function atomicWriteFile(filePath, content) {
-  await mkdir8(dirname8(filePath), { recursive: true });
-  const tmp = `${filePath}.${randomUUID6()}.tmp`;
+  await mkdir9(dirname8(filePath), { recursive: true });
+  const tmp = `${filePath}.${randomUUID7()}.tmp`;
   try {
-    await writeFile7(tmp, content, { encoding: "utf8", flag: "w" });
-    await rename7(tmp, filePath);
+    await writeFile8(tmp, content, { encoding: "utf8", flag: "w" });
+    await rename8(tmp, filePath);
   } catch (err) {
-    await rm8(tmp, { force: true }).catch(() => {
+    await rm9(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
 }
 async function getMcpMtimeMs(filePath) {
   try {
-    const s = await stat6(filePath);
+    const s = await stat7(filePath);
     return s.mtimeMs;
   } catch {
     return null;
@@ -7023,7 +7283,7 @@ var CursorInstaller = class {
       if (info === "missing") continue;
       if (info === "skill-dir") {
         if (!dryRun) {
-          await rm8(filePath, { recursive: true, force: true });
+          await rm9(filePath, { recursive: true, force: true });
         }
         removedFiles.push(filePath);
         continue;
@@ -7037,13 +7297,13 @@ var CursorInstaller = class {
           continue;
         }
         if (!dryRun) {
-          await rm8(filePath, { force: true });
+          await rm9(filePath, { force: true });
         }
         removedFiles.push(filePath);
         continue;
       }
       if (!dryRun) {
-        await rm8(filePath, { force: true });
+        await rm9(filePath, { force: true });
       }
       removedFiles.push(filePath);
     }
@@ -7091,10 +7351,10 @@ var CursorInstaller = class {
     const prevEntry = registryStore.get(plugin.ref);
     const prevFiles = new Set(prevEntry?.targets?.cursor?.files ?? []);
     if (plugin.capabilities.includes("skills")) {
-      const skillsSourceDir = resolve13(plugin.sourceDir, "skills");
+      const skillsSourceDir = resolve14(plugin.sourceDir, "skills");
       const skillDirs = await listSkillDirs(skillsSourceDir);
       for (const skillName of skillDirs) {
-        const srcDir = resolve13(skillsSourceDir, skillName);
+        const srcDir = resolve14(skillsSourceDir, skillName);
         const destDir = cursorSkillDir(this.home, skillName);
         const bridgeRulePath = cursorRuleMdcPath(this.home, skillName);
         if (await dirExists2(destDir)) {
@@ -7126,10 +7386,10 @@ var CursorInstaller = class {
       }
     }
     if (plugin.capabilities.includes("rules")) {
-      const rulesSourceDir = resolve13(plugin.sourceDir, "rules");
+      const rulesSourceDir = resolve14(plugin.sourceDir, "rules");
       const rulesFiles = await listRuleMdFiles(rulesSourceDir);
       for (const ruleFile of rulesFiles) {
-        const srcPath = resolve13(rulesSourceDir, ruleFile);
+        const srcPath = resolve14(rulesSourceDir, ruleFile);
         const ruleName = ruleFile.replace(/\.md$/i, "");
         const destPath = cursorRuleMdcPath(this.home, ruleName);
         await assertMdcWritable(destPath, args.force);
@@ -7166,7 +7426,7 @@ var CursorInstaller = class {
   // -------------------------------------------------------------------------
   async writeSkillDir(args) {
     const preExisted = await dirExists2(args.destDir);
-    await mkdir8(dirname8(args.destDir), { recursive: true });
+    await mkdir9(dirname8(args.destDir), { recursive: true });
     if (preExisted) {
       const backup = `${args.destDir}.${process.pid}.${Date.now()}.bak`;
       await safeRename(args.destDir, backup);
@@ -7315,7 +7575,7 @@ async function listRuleMdFiles(rulesDir) {
 }
 async function dirExists2(p) {
   try {
-    const s = await stat6(p);
+    const s = await stat7(p);
     return s.isDirectory();
   } catch {
     return false;
@@ -7324,20 +7584,20 @@ async function dirExists2(p) {
 async function fileExists(p) {
   try {
     await access8(p, fsConstants8.F_OK);
-    const s = await stat6(p);
+    const s = await stat7(p);
     return s.isFile();
   } catch {
     return false;
   }
 }
 async function safeRename(from, to) {
-  const { rename: rename8 } = await import("fs/promises");
-  await rename8(from, to);
+  const { rename: rename9 } = await import("fs/promises");
+  await rename9(from, to);
 }
 async function classifyArtifactPath(p) {
   let s;
   try {
-    s = await stat6(p);
+    s = await stat7(p);
   } catch {
     return "missing";
   }
@@ -7350,14 +7610,14 @@ async function classifyArtifactPath(p) {
 }
 
 // src/migration/cleanup.ts
-import { lstat as lstat3, rm as rm9, unlink as unlink2 } from "fs/promises";
+import { lstat as lstat3, rm as rm10, unlink as unlink2 } from "fs/promises";
 import { homedir as homedir9 } from "os";
-import { resolve as resolve15 } from "path";
+import { resolve as resolve16 } from "path";
 
 // src/migration/detect.ts
-import { access as access9, lstat as lstat2, readFile as readFile11, readlink as readlink2, stat as stat7 } from "fs/promises";
+import { access as access9, lstat as lstat2, readFile as readFile11, readlink as readlink2, stat as stat8 } from "fs/promises";
 import { homedir as homedir8 } from "os";
-import { isAbsolute as isAbsolute4, resolve as resolve14 } from "path";
+import { isAbsolute as isAbsolute4, resolve as resolve15 } from "path";
 var LEGACY_ASSET_MANIFEST_RELATIVE = ".rush/plugins/claude-code/asset-manifest.json";
 var LEGACY_ASSETS_DIR_RELATIVE = ".rush/plugins/claude-code/assets";
 var LEGACY_CLAUDE_CODE_DIR_RELATIVE = ".rush/plugins/claude-code";
@@ -7376,7 +7636,7 @@ async function isSymlinkPointingInto(linkPath, expectedTarget) {
     const lst = await lstat2(linkPath);
     if (!lst.isSymbolicLink()) return false;
     const rawTarget = await readlink2(linkPath);
-    const resolvedTarget = isAbsolute4(rawTarget) ? rawTarget : resolve14(linkPath, "..", rawTarget);
+    const resolvedTarget = isAbsolute4(rawTarget) ? rawTarget : resolve15(linkPath, "..", rawTarget);
     return resolvedTarget === expectedTarget || resolvedTarget.startsWith(`${expectedTarget}/`);
   } catch {
     return false;
@@ -7413,10 +7673,10 @@ async function hasLegacyMcpWithoutEnabled(settingsJsonPath) {
 }
 async function detectLegacyInstall(opts = {}) {
   const home = opts.home ?? homedir8();
-  const assetManifestPath = resolve14(home, LEGACY_ASSET_MANIFEST_RELATIVE);
-  const legacyAssetsDir = resolve14(home, LEGACY_ASSETS_DIR_RELATIVE);
-  const skillSymlinkPath = resolve14(home, LEGACY_SKILL_SYMLINK_RELATIVE);
-  const settingsJsonPath = resolve14(home, CLAUDE_SETTINGS_JSON_RELATIVE);
+  const assetManifestPath = resolve15(home, LEGACY_ASSET_MANIFEST_RELATIVE);
+  const legacyAssetsDir = resolve15(home, LEGACY_ASSETS_DIR_RELATIVE);
+  const skillSymlinkPath = resolve15(home, LEGACY_SKILL_SYMLINK_RELATIVE);
+  const settingsJsonPath = resolve15(home, CLAUDE_SETTINGS_JSON_RELATIVE);
   const [hasAssetManifest, hasLegacySkillSymlink, legacyMcpWithoutEnabled] = await Promise.all([
     pathExists7(assetManifestPath),
     isSymlinkPointingInto(skillSymlinkPath, legacyAssetsDir),
@@ -7431,9 +7691,9 @@ async function detectLegacyInstall(opts = {}) {
 }
 async function detectLegacyVersion(opts = {}) {
   const home = opts.home ?? homedir8();
-  const manifestPath = resolve14(home, LEGACY_ASSET_MANIFEST_RELATIVE);
+  const manifestPath = resolve15(home, LEGACY_ASSET_MANIFEST_RELATIVE);
   try {
-    const lst = await stat7(manifestPath);
+    const lst = await stat8(manifestPath);
     if (!lst.isFile()) return "0.7.x";
     const raw = await readFile11(manifestPath, "utf8");
     const parsed = JSON.parse(raw);
@@ -7449,9 +7709,9 @@ async function detectLegacyVersion(opts = {}) {
 
 // src/migration/cleanup.ts
 async function cleanupLegacyDir(home) {
-  const dir = resolve15(home, LEGACY_CLAUDE_CODE_DIR_RELATIVE);
+  const dir = resolve16(home, LEGACY_CLAUDE_CODE_DIR_RELATIVE);
   try {
-    await rm9(dir, { recursive: true, force: true });
+    await rm10(dir, { recursive: true, force: true });
     return { ok: true };
   } catch (err) {
     return {
@@ -7461,7 +7721,7 @@ async function cleanupLegacyDir(home) {
   }
 }
 async function cleanupLegacySymlink(home) {
-  const path4 = resolve15(home, LEGACY_SKILL_SYMLINK_RELATIVE);
+  const path4 = resolve16(home, LEGACY_SKILL_SYMLINK_RELATIVE);
   try {
     let lst;
     try {
@@ -7483,7 +7743,7 @@ async function cleanupLegacySymlink(home) {
   }
 }
 async function cleanupLegacyMcp(home) {
-  const path4 = resolve15(home, CLAUDE_SETTINGS_JSON_RELATIVE);
+  const path4 = resolve16(home, CLAUDE_SETTINGS_JSON_RELATIVE);
   try {
     const { data, existed } = await readJsonFile(
       path4,
@@ -7539,13 +7799,13 @@ function errorMessage(err) {
 }
 
 // src/migration/log.ts
-import { appendFile as appendFile2, mkdir as mkdir9 } from "fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir10 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname9, resolve as resolve16 } from "path";
+import { dirname as dirname9, resolve as resolve17 } from "path";
 var MIGRATION_LOG_RELATIVE_PATH = ".rush/plugins/migration-failed.log";
 function resolveMigrationLogPath(opts = {}) {
   const home = opts.home ?? homedir10();
-  return resolve16(home, MIGRATION_LOG_RELATIVE_PATH);
+  return resolve17(home, MIGRATION_LOG_RELATIVE_PATH);
 }
 async function appendMigrationFailure(reason, opts = {}) {
   const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
@@ -7562,7 +7822,7 @@ async function appendMigrationFailure(reason, opts = {}) {
   const payload = `${lines.join("\n")}
 `;
   try {
-    await mkdir9(dirname9(logPath), { recursive: true });
+    await mkdir10(dirname9(logPath), { recursive: true });
     await appendFile2(logPath, payload, { encoding: "utf8" });
   } catch {
   }
@@ -7582,8 +7842,8 @@ import {
 
 // src/plugins/capabilities.ts
 import { constants as fsConstants9 } from "fs";
-import { access as access10, readdir as readdir4, stat as stat8 } from "fs/promises";
-import { extname as extname2, resolve as resolve17 } from "path";
+import { access as access10, readdir as readdir4, stat as stat9 } from "fs/promises";
+import { extname as extname2, resolve as resolve18 } from "path";
 var CAPABILITY_ORDER = [
   "commands",
   "skills",
@@ -7612,10 +7872,10 @@ async function scanCapabilities(sourceDir, manifest) {
   return CAPABILITY_ORDER.filter((cap) => found.has(cap));
 }
 async function hasCommands(sourceDir) {
-  return dirHasFileWithExt(resolve17(sourceDir, "commands"), ".md");
+  return dirHasFileWithExt(resolve18(sourceDir, "commands"), ".md");
 }
 async function hasSkills(sourceDir) {
-  const skillsDir = resolve17(sourceDir, "skills");
+  const skillsDir = resolve18(sourceDir, "skills");
   if (await dirExists3(skillsDir)) {
     let entries;
     try {
@@ -7625,7 +7885,7 @@ async function hasSkills(sourceDir) {
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const skillMdPath = resolve17(skillsDir, entry.name, "SKILL.md");
+      const skillMdPath = resolve18(skillsDir, entry.name, "SKILL.md");
       if (await fileExists2(skillMdPath)) {
         return true;
       }
@@ -7634,10 +7894,10 @@ async function hasSkills(sourceDir) {
   return hasClaudeStyleSkills(sourceDir);
 }
 async function hasRules(sourceDir) {
-  return dirHasFileWithExt(resolve17(sourceDir, "rules"), ".md");
+  return dirHasFileWithExt(resolve18(sourceDir, "rules"), ".md");
 }
 async function hasHooks(sourceDir) {
-  const hooksDir = resolve17(sourceDir, "hooks");
+  const hooksDir = resolve18(sourceDir, "hooks");
   if (!await dirExists3(hooksDir)) {
     return false;
   }
@@ -7679,7 +7939,7 @@ async function dirHasFileWithExt(dirPath, ext) {
   );
 }
 async function hasClaudeStyleSkills(sourceDir) {
-  const dotSkillsDir = resolve17(sourceDir, ".skills");
+  const dotSkillsDir = resolve18(sourceDir, ".skills");
   if (!await dirExists3(dotSkillsDir)) {
     return false;
   }
@@ -7691,7 +7951,7 @@ async function hasClaudeStyleSkills(sourceDir) {
       return false;
     }
     for (const entry of entries) {
-      const abs = resolve17(dirPath, entry.name);
+      const abs = resolve18(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (await walk2(abs)) return true;
         continue;
@@ -7706,7 +7966,7 @@ async function hasClaudeStyleSkills(sourceDir) {
 }
 async function dirExists3(p) {
   try {
-    const s = await stat8(p);
+    const s = await stat9(p);
     return s.isDirectory();
   } catch {
     return false;
@@ -7715,7 +7975,7 @@ async function dirExists3(p) {
 async function fileExists2(p) {
   try {
     await access10(p, fsConstants9.R_OK);
-    const s = await stat8(p);
+    const s = await stat9(p);
     return s.isFile();
   } catch {
     return false;
@@ -7786,10 +8046,10 @@ var InvalidPluginVersionError = class extends PluginResolverError {
 // src/plugins/manifest.ts
 import { constants as fsConstants10 } from "fs";
 import { access as access11, readFile as readFile12 } from "fs/promises";
-import { resolve as resolve18 } from "path";
+import { resolve as resolve19 } from "path";
 var PLUGIN_MANIFEST_RELATIVE_PATH = ".claude-plugin/plugin.json";
 async function readPluginManifest(pluginName, sourceDir) {
-  const manifestPath = resolve18(sourceDir, PLUGIN_MANIFEST_RELATIVE_PATH);
+  const manifestPath = resolve19(sourceDir, PLUGIN_MANIFEST_RELATIVE_PATH);
   try {
     await access11(manifestPath, fsConstants10.R_OK);
   } catch {
@@ -8458,6 +8718,11 @@ function claudeMarketplaceSourceFrom(marketplace) {
         rootDir: marketplace.rootDir,
         descriptor: { kind: "git", url: src.url }
       };
+    case "rush":
+      return {
+        rootDir: marketplace.rootDir,
+        descriptor: { kind: "directory", path: marketplace.rootDir }
+      };
     default:
       return void 0;
   }
@@ -8534,45 +8799,151 @@ async function runInstall(input) {
     marketplace = await cache.get(ref.marketplace);
   } catch (err) {
     if (err instanceof MarketplaceNotFoundError) {
+      if (ref.marketplace === "rush" || ref.marketplace === "rush-marketplace") {
+        const apiHost = getGlobalConfig().api.replace(/^https?:\/\//, "");
+        const rushSource = parseSource(`rush://${apiHost}`);
+        await cache.add(rushSource, { as: ref.marketplace });
+        marketplace = await cache.get(ref.marketplace);
+      } else {
+        throw new RushError(
+          `Marketplace '${ref.marketplace}' is not in the local cache. Run 'rush-ai marketplace add <source>' first.`,
+          { marketplaceName: ref.marketplace },
+          "MARKETPLACE_NOT_FOUND",
+          2
+        );
+      }
+    } else {
+      throw err;
+    }
+  }
+  if (marketplace.source.kind === "rush") {
+    const TWENTY_FOUR_HOURS = 24 * 60 * 60 * 1e3;
+    const entryMissing = !marketplace.manifest.plugins.some(
+      (p) => p.name === ref.name
+    );
+    const cacheList = await cache.list();
+    const cacheEntry = cacheList.find((m) => m.name === ref.marketplace);
+    const isStale = cacheEntry?.cachedAt ? Date.now() - new Date(cacheEntry.cachedAt).getTime() > TWENTY_FOUR_HOURS : false;
+    if (entryMissing || isStale) {
+      marketplace = await cache.update(ref.marketplace);
+    }
+    if (!marketplace.manifest.plugins.some((p) => p.name === ref.name)) {
       throw new RushError(
-        `Marketplace '${ref.marketplace}' is not in the local cache. Run 'rush-ai marketplace add <source>' first.`,
-        { marketplaceName: ref.marketplace },
-        "MARKETPLACE_NOT_FOUND",
+        `Plugin '${ref.name}' not found in rush marketplace. Verify the plugin exists on the Web and is public.`,
+        { pluginName: ref.name, marketplace: ref.marketplace },
+        "PLUGIN_NOT_FOUND_IN_MARKETPLACE",
         2
       );
     }
-    throw err;
+  }
+  if (marketplace.source.kind === "rush") {
+    const pluginDir = resolve20(marketplace.rootDir, "plugins", ref.name);
+    const manifestPath = resolve20(pluginDir, ".claude-plugin/plugin.json");
+    const alreadyMaterialized = await pathExists2(manifestPath);
+    const hasNewSecrets = input.secrets && Object.keys(input.secrets).length > 0;
+    const shouldMaterialize = !alreadyMaterialized || force || hasNewSecrets;
+    if (shouldMaterialize && dryRun && !alreadyMaterialized) {
+      throw new RushError(
+        `Plugin '${ref.name}' has not been installed yet. Run without --dry-run first to fetch and cache the plugin manifest.`,
+        { pluginName: ref.name },
+        "PLUGIN_NOT_MATERIALIZED",
+        2
+      );
+    }
+    if (shouldMaterialize && !dryRun) {
+      const rushSource = marketplace.source;
+      const token = getAuthToken();
+      let apiManifest;
+      try {
+        apiManifest = await fetchRushPlugin(rushSource, ref.name, { token });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new RushError(
+          `Failed to fetch plugin '${ref.name}' from rush marketplace: ${msg}`,
+          { pluginName: ref.name, marketplace: ref.marketplace },
+          "PLUGIN_FETCH_FAILED",
+          2
+        );
+      }
+      let secrets = {};
+      if (apiManifest.requiredSecrets && apiManifest.requiredSecrets.length > 0) {
+        const presetSecrets = input.secrets ?? {};
+        const missingMeta = {};
+        for (const s of apiManifest.requiredSecrets) {
+          if (!(s.key in presetSecrets)) {
+            const isSecret = s.type === "secret" || s.type === "password";
+            missingMeta[s.key] = {
+              type: isSecret ? "secret" : "text",
+              required: true,
+              helpUrl: s.helpUrl
+            };
+          }
+        }
+        const prompted = Object.keys(missingMeta).length > 0 ? await promptCredentials(missingMeta) : {};
+        secrets = { ...prompted, ...presetSecrets };
+      }
+      try {
+        await materializeRushPlugin(rushSource, ref.name, pluginDir, {
+          token,
+          secrets
+        });
+      } catch (err) {
+        if (err instanceof SkillAuthError) {
+          throw new RushError(
+            err.message,
+            { pluginName: ref.name, marketplace: ref.marketplace },
+            "AUTH_REQUIRED",
+            2
+          );
+        }
+        throw err;
+      }
+    }
   }
   const resolveFn = input.resolvePluginFn ?? resolvePlugin;
   let plugin;
   try {
     plugin = await resolveFn(ref, marketplace);
   } catch (err) {
-    if (err instanceof PluginNotFoundInMarketplaceError) {
+    if (err instanceof PluginNotFoundInMarketplaceError && marketplace.source.kind === "rush") {
+      marketplace = await cache.update(ref.marketplace);
+      try {
+        plugin = await resolveFn(ref, marketplace);
+      } catch (retryErr) {
+        if (retryErr instanceof PluginNotFoundInMarketplaceError) {
+          throw new RushError(
+            retryErr.message,
+            { pluginName: ref.name, marketplace: ref.marketplace },
+            "PLUGIN_NOT_FOUND_IN_MARKETPLACE",
+            2
+          );
+        }
+        throw retryErr;
+      }
+    } else if (err instanceof PluginNotFoundInMarketplaceError) {
       throw new RushError(
         err.message,
         { pluginName: ref.name, marketplace: ref.marketplace },
         "PLUGIN_NOT_FOUND_IN_MARKETPLACE",
         2
       );
-    }
-    if (err instanceof PluginManifestNotFoundError) {
+    } else if (err instanceof PluginManifestNotFoundError) {
       throw new RushError(
         err.message,
         { pluginName: ref.name, marketplace: ref.marketplace },
         "PLUGIN_MANIFEST_NOT_FOUND",
         2
       );
-    }
-    if (err instanceof PluginResolverError) {
+    } else if (err instanceof PluginResolverError) {
       throw new RushError(
         err.message,
         { pluginName: ref.name, marketplace: ref.marketplace },
         "PLUGIN_RESOLVE_FAILED",
         2
       );
+    } else {
+      throw err;
     }
-    throw err;
   }
   let migrationOutcome;
   if (!dryRun) {
@@ -8683,14 +9054,38 @@ function registerInstallCommand(group, _root) {
   ).argument("<ref>", "plugin reference: <name> or <name>@<marketplace>").option(
     "--target <list>",
     `comma-separated targets (default: ${[...DEFAULT_TARGETS].join(",")})`
-  ).option("--force", "reinstall even if same version is already installed").option("--dry-run", "don't touch disk; print the plan").action(
+  ).option("--force", "reinstall even if same version is already installed").option("--dry-run", "don't touch disk; print the plan").option(
+    "--secret <key=value>",
+    "pre-set MCP secret values (repeatable)",
+    (val, acc) => {
+      acc.push(val);
+      return acc;
+    },
+    []
+  ).action(
     async (ref, opts) => {
+      const secrets = {};
+      if (opts.secret && opts.secret.length > 0) {
+        for (const pair of opts.secret) {
+          const eqIdx = pair.indexOf("=");
+          if (eqIdx <= 0) {
+            throw new RushError(
+              `Invalid --secret format '${pair}'. Expected KEY=VALUE.`,
+              { raw: pair },
+              "INVALID_SECRET_FORMAT",
+              2
+            );
+          }
+          secrets[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1);
+        }
+      }
       const result = await runInstall({
         ref,
         ...opts.target !== void 0 ? { targetRaw: opts.target } : {},
         targetExplicit: opts.target !== void 0,
         ...opts.force ? { force: true } : {},
         ...opts.dryRun ? { dryRun: true } : {},
+        ...Object.keys(secrets).length > 0 ? { secrets } : {},
         migrationReporter: {
           info: (line) => output.dim(line),
           warn: (line) => output.warn(line)
@@ -9313,7 +9708,7 @@ function registerPluginCommand(program) {
 
 // src/commands/skill/index.ts
 import { existsSync as existsSync11, readdirSync, readFileSync as readFileSync7 } from "fs";
-import { basename as basename3, resolve as resolve19 } from "path";
+import { basename as basename3, resolve as resolve21 } from "path";
 var SKILL_DESCRIPTION = "Print agent usage skills (hand-off, agent-shelf, ...) as raw markdown.";
 var SKILL_HELP_AFTER = `
 Examples:
@@ -9330,11 +9725,11 @@ function resolveSkillsDir() {
   const baseDir = import.meta.dirname ?? __dirname;
   if (!baseDir) return null;
   const candidates = [
-    resolve19(baseDir, "skills"),
-    resolve19(baseDir, "..", "skills"),
-    resolve19(baseDir, "..", "..", "skills"),
-    resolve19(baseDir, "..", "..", "..", "skills"),
-    resolve19(baseDir, "..", "..", "..", "..", "skills")
+    resolve21(baseDir, "skills"),
+    resolve21(baseDir, "..", "skills"),
+    resolve21(baseDir, "..", "..", "skills"),
+    resolve21(baseDir, "..", "..", "..", "skills"),
+    resolve21(baseDir, "..", "..", "..", "..", "skills")
   ];
   for (const p of candidates) {
     if (existsSync11(p)) return p;
@@ -9360,7 +9755,7 @@ function registerSkillCommand(program) {
       return;
     }
     const target = name ?? "README";
-    const file2 = resolve19(dir, `${target}.md`);
+    const file2 = resolve21(dir, `${target}.md`);
     if (!existsSync11(file2)) {
       output.error(`Unknown skill "${target}".`);
       output.dim(`Available: ${available.join(", ") || "(none)"}`);
@@ -9373,7 +9768,7 @@ function registerSkillCommand(program) {
 
 // src/commands/task/index.ts
 import { createWriteStream } from "fs";
-import { mkdir as mkdir10, readFile as readFile14, stat as stat9 } from "fs/promises";
+import { mkdir as mkdir11, readFile as readFile14, stat as stat10 } from "fs/promises";
 import path3 from "path";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
@@ -9399,13 +9794,13 @@ async function readStdinIfPiped() {
   if (process.stdin.isTTY) {
     return null;
   }
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve23, reject) => {
     const chunks = [];
     process.stdin.on("data", (chunk) => {
       chunks.push(chunk);
     });
     process.stdin.on("end", () => {
-      resolve21(Buffer.concat(chunks).toString("utf-8").trim());
+      resolve23(Buffer.concat(chunks).toString("utf-8").trim());
     });
     process.stdin.on("error", reject);
   });
@@ -9606,7 +10001,7 @@ function buildDeployUrl(prefix, env, apiBaseUrl) {
 }
 
 // src/commands/task/push.ts
-import { resolve as resolve20 } from "path";
+import { resolve as resolve22 } from "path";
 import chalk5 from "chalk";
 
 // src/util/env-file.ts
@@ -9750,7 +10145,7 @@ function registerPushSubcommand(task, program) {
     requireAuth();
     const format = resolveFormat(program.opts());
     const client = createClient();
-    const projectPath = resolve20(opts.path);
+    const projectPath = resolve22(opts.path);
     if (format !== "json") {
       output.info("Checking project readiness...");
     }
@@ -9927,6 +10322,9 @@ function pushWithRouting(projectPath, source, envGitRemote) {
 
 // src/commands/task/deploy.ts
 var DOMAIN_PREFIX_REGEX = /^[a-z0-9][a-z0-9-]{0,28}[a-z0-9]$|^[a-z0-9]$/;
+function getApiBaseUrl2() {
+  return process.env.RUSH_API_URL ?? getGlobalConfig().api;
+}
 function validateDomainPrefix(prefix) {
   if (!DOMAIN_PREFIX_REGEX.test(prefix)) {
     throw new RushError(
@@ -10178,7 +10576,7 @@ async function confirmPublish(args) {
   return answer.trim().toLowerCase().startsWith("y");
 }
 function readOneLine() {
-  return new Promise((resolve21) => {
+  return new Promise((resolve23) => {
     let acc = "";
     const onData = (chunk) => {
       acc += chunk.toString("utf-8");
@@ -10186,7 +10584,7 @@ function readOneLine() {
       if (nlIdx !== -1) {
         process.stdin.removeListener("data", onData);
         process.stdin.pause();
-        resolve21(acc.slice(0, nlIdx));
+        resolve23(acc.slice(0, nlIdx));
       }
     };
     process.stdin.resume();
@@ -10206,7 +10604,7 @@ async function publishNextjs(client, projectId, commitHash, domain, format) {
       }
     });
     if (domain !== void 0) {
-      const { api: apiBase } = getGlobalConfig();
+      const apiBase = getApiBaseUrl2();
       return {
         url: buildDeployUrl(domain, "production", apiBase),
         domain: buildDeployDomain(domain, "production", apiBase)
@@ -10247,7 +10645,7 @@ async function publishStatic(client, projectId, commitHash, env, domain) {
       { taskId: projectId, reason: "publish_failed" }
     );
   }
-  const { api: apiBase } = getGlobalConfig();
+  const apiBase = getApiBaseUrl2();
   const resolvedDomain = domain !== void 0 ? buildDeployDomain(domain, env, apiBase) : publishResp.data.data?.domain;
   const resolvedUrl = domain !== void 0 ? buildDeployUrl(domain, env, apiBase) : publishResp.data.data?.url;
   const versionId = commitHash;
@@ -10355,7 +10753,7 @@ function registerDomainSubcommand(task, program) {
       return;
     }
     if (data.available) {
-      const { api } = getGlobalConfig();
+      const api = process.env.RUSH_API_URL ?? getGlobalConfig().api;
       const url = buildDeployUrl(prefix, "production", api);
       output.success(`Prefix available: ${url}`);
     } else {
@@ -10943,7 +11341,7 @@ async function downloadFile(file2, destPath, client) {
   if (!response.body) {
     throw new Error("No response body");
   }
-  await mkdir10(path3.dirname(destPath), { recursive: true });
+  await mkdir11(path3.dirname(destPath), { recursive: true });
   const nodeStream = Readable.fromWeb(
     response.body
   );
@@ -11483,7 +11881,7 @@ async function uploadFileForTask(client, localPath) {
   const resolved = path3.resolve(localPath);
   let fileStat;
   try {
-    fileStat = await stat9(resolved);
+    fileStat = await stat10(resolved);
   } catch {
     throw new RushError(`File not found: ${localPath}`);
   }
@@ -11549,7 +11947,7 @@ function registerCommands(program) {
 }
 
 // src/util/update-check.ts
-import { mkdir as mkdir11, readFile as readFile15, writeFile as writeFile8 } from "fs/promises";
+import { mkdir as mkdir12, readFile as readFile15, writeFile as writeFile9 } from "fs/promises";
 import { homedir as homedir12 } from "os";
 import { dirname as dirname10, join as join10 } from "path";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
@@ -11574,8 +11972,8 @@ function isNewerVersion(current, latest) {
 }
 async function writeLastCheck(checkFile) {
   try {
-    await mkdir11(dirname10(checkFile), { recursive: true });
-    await writeFile8(checkFile, JSON.stringify({ lastCheck: Date.now() }));
+    await mkdir12(dirname10(checkFile), { recursive: true });
+    await writeFile9(checkFile, JSON.stringify({ lastCheck: Date.now() }));
   } catch {
   }
 }