rush-ai 0.19.0 → 0.21.0

package/dist/chunk-C7KJUHEF.js

@@ -0,0 +1,830 @@
+#!/usr/bin/env node
+import {
+  getAuthToken
+} from "./chunk-OIKYNVKO.js";
+import {
+  output
+} from "./chunk-T5S6NCHZ.js";
+
+// src/commands/marketplace/_codex-content-loader.ts
+import { constants as fsConstants } from "fs";
+import { access, readFile, stat as stat2 } from "fs/promises";
+import { resolve as pathResolve2, sep } from "path";
+
+// src/marketplaces/rush.ts
+import { execFileSync, spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { mkdir, rename, rm, stat, writeFile } from "fs/promises";
+import { resolve as pathResolve, resolve } from "path";
+var RUSH_API_FETCH_TIMEOUT_MS = 3e4;
+function fetchInitWithTimeout(headers) {
+  return {
+    headers,
+    signal: AbortSignal.timeout(RUSH_API_FETCH_TIMEOUT_MS)
+  };
+}
+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, fetchInitWithTimeout(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, fetchInitWithTimeout(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 fetchRushOfficialFile(source, pluginSlug, filePath, opts = {}) {
+  const fetchFn = opts.fetchFn ?? fetch;
+  const encoded = filePath.split("/").filter((s) => s.length > 0).map((s) => encodeURIComponent(s)).join("/");
+  const url = `${inferProtocol(source.host)}${source.host}/api/marketplace/${encodeURIComponent(pluginSlug)}/files/${encoded}`;
+  const headers = { Accept: "application/json" };
+  if (opts.token) headers.Authorization = `Bearer ${opts.token}`;
+  const response = await fetchFn(url, fetchInitWithTimeout(headers));
+  if (response.status === 404) {
+    throw new Error(
+      `File '${filePath}' not found in official plugin '${pluginSlug}'`
+    );
+  }
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch file '${filePath}' 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);
+  if (manifest.source === "claude-plugins-official") {
+    if (manifest.redirectTo) {
+      await materializeOfficialExternal(manifest, targetDir);
+      return manifest;
+    }
+    await materializeOfficialLocal(
+      source,
+      pluginSlug,
+      manifest,
+      targetDir,
+      opts
+    );
+    return manifest;
+  }
+  if (manifest.source === "rush-git-import") {
+    await materializeOfficialLocal(
+      source,
+      pluginSlug,
+      manifest,
+      targetDir,
+      opts
+    );
+    return manifest;
+  }
+  return materializeRushUserPlugin(
+    source,
+    pluginSlug,
+    manifest,
+    targetDir,
+    opts
+  );
+}
+async function materializeRushUserPlugin(source, pluginSlug, manifest, targetDir, 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);
+    }
+    mcpServers = normalizeMcpServerDefaults(mcpServers);
+  }
+  const pluginJson = buildPluginJsonShape(manifest, {
+    mcpServers
+  });
+  const tmpDir = `${targetDir}.${randomUUID()}.tmp`;
+  try {
+    const pluginJsonDir = resolve(tmpDir, ".claude-plugin");
+    await mkdir(pluginJsonDir, { recursive: true });
+    await writeFile(
+      resolve(pluginJsonDir, "plugin.json"),
+      `${JSON.stringify(pluginJson, null, 2)}
+`,
+      "utf8"
+    );
+    if (manifest.skills && manifest.skills.length > 0) {
+      await writeFile(
+        resolve(tmpDir, "skills.json"),
+        '{"skills":{}}\n',
+        "utf8"
+      );
+      const reskillHomeDir = resolve(tmpDir, ".reskill-home");
+      await mkdir(reskillHomeDir, { recursive: true });
+      const registryUrl = `${inferProtocol(source.host)}${source.host}`;
+      for (const [index, skill] of manifest.skills.entries()) {
+        try {
+          output.dim(
+            `  Fetching skill ${index + 1}/${manifest.skills.length}: ${skill.name}`
+          );
+          const args = [
+            "-y",
+            "reskill@latest",
+            "install",
+            skill.name,
+            "--agent",
+            "claude-code",
+            "--mode",
+            "copy",
+            "--no-save",
+            "--skip-manifest",
+            "-y",
+            "-f",
+            "-r",
+            registryUrl,
+            ...opts.token ? ["-t", opts.token] : []
+          ];
+          execFileSync("npx", args, {
+            cwd: tmpDir,
+            // 3 分钟 — 覆盖 npx 首次下载 reskill 包的冷启动场景
+            // （warm cache 时 reskill 实际运行只需 ~7s）
+            timeout: 18e4,
+            stdio: "pipe",
+            env: {
+              ...process.env,
+              HOME: reskillHomeDir,
+              npm_config_cache: resolve(reskillHomeDir, ".npm")
+            }
+          });
+        } 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 = resolve(tmpDir, ".skills");
+    const claudeSkillsDir = resolve(tmpDir, ".claude", "skills");
+    const skillsDir = resolve(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);
+      }
+    }
+    if (await stat(claudeSkillsDir).then((s) => s.isDirectory()).catch(() => false)) {
+      if (!await stat(skillsDir).then((s) => s.isDirectory()).catch(() => false)) {
+        await rename(claudeSkillsDir, skillsDir);
+      }
+    }
+    await rm(resolve(tmpDir, "skills.json"), { force: true });
+    await rm(resolve(tmpDir, ".reskill-home"), {
+      recursive: true,
+      force: true
+    });
+    await rm(resolve(tmpDir, ".cursor"), { recursive: true, force: true });
+    await rm(resolve(tmpDir, ".claude"), { recursive: true, force: true });
+    await rm(resolve(tmpDir, ".codex"), { recursive: true, force: true });
+    await rm(resolve(tmpDir, ".github"), { recursive: true, force: true });
+    await rm(resolve(tmpDir, ".opencode"), { recursive: true, force: true });
+    await rm(targetDir, { recursive: true, force: true });
+    await mkdir(resolve(targetDir, ".."), { recursive: true });
+    await rename(tmpDir, targetDir);
+  } catch (err) {
+    await rm(tmpDir, { recursive: true, force: true }).catch(() => {
+    });
+    throw err;
+  }
+  return manifest;
+}
+async function materializeOfficialLocal(source, pluginSlug, manifest, targetDir, 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 = buildPluginJsonShape(manifest, {
+    mcpServers
+  });
+  const tmpDir = `${targetDir}.${randomUUID()}.tmp`;
+  try {
+    await mkdir(resolve(tmpDir, ".claude-plugin"), { recursive: true });
+    await writeFile(
+      resolve(tmpDir, ".claude-plugin", "plugin.json"),
+      `${JSON.stringify(pluginJson, null, 2)}
+`,
+      "utf8"
+    );
+    if (Object.keys(mcpServers).length > 0) {
+      await writeFile(
+        resolve(tmpDir, ".mcp.json"),
+        `${JSON.stringify({ mcpServers }, null, 2)}
+`,
+        "utf8"
+      );
+    }
+    await fetchAndWriteOfficialFiles(
+      source,
+      pluginSlug,
+      manifest,
+      tmpDir,
+      opts
+    );
+    await rm(targetDir, { recursive: true, force: true });
+    await mkdir(resolve(targetDir, ".."), { recursive: true });
+    await rename(tmpDir, targetDir);
+  } catch (err) {
+    await rm(tmpDir, { recursive: true, force: true }).catch(() => {
+    });
+    throw err;
+  }
+}
+async function fetchAndWriteOfficialFiles(source, pluginSlug, manifest, rootDir, opts) {
+  const entries = [];
+  for (const s of manifest.skills ?? []) {
+    if (s.path) {
+      const skillFilePath = s.path.endsWith(".md") || s.path.endsWith(".MD") ? s.path : `${s.path.endsWith("/") ? s.path.slice(0, -1) : s.path}/SKILL.md`;
+      entries.push({ kind: "skill", name: s.name, path: skillFilePath });
+    }
+  }
+  for (const a of manifest.agents ?? []) {
+    entries.push({ kind: "agent", name: a.name, path: a.path });
+  }
+  for (const h of manifest.hooks ?? []) {
+    entries.push({ kind: "hook", name: h.name, path: h.path });
+  }
+  for (const c of manifest.commands ?? []) {
+    entries.push({ kind: "command", name: c.name, path: c.path });
+  }
+  if (entries.length === 0) return;
+  const fetchOpts = {};
+  if (opts.fetchFn !== void 0) fetchOpts.fetchFn = opts.fetchFn;
+  if (opts.token !== void 0 && opts.token !== null) {
+    fetchOpts.token = opts.token;
+  }
+  for (const e of entries) {
+    try {
+      const file = await fetchRushOfficialFile(
+        source,
+        pluginSlug,
+        e.path,
+        fetchOpts
+      );
+      if (file.truncated) {
+        output.warn(
+          `  Warning: ${e.kind} '${e.name}' file '${e.path}' was truncated during sync; please view on web`
+        );
+        continue;
+      }
+      let body = null;
+      if (typeof file.content === "string") {
+        body = file.content;
+      } else if (typeof file.signedUrl === "string") {
+        const fetchFn = opts.fetchFn ?? fetch;
+        const res = await fetchFn(file.signedUrl);
+        if (res.ok) {
+          const arr = await res.arrayBuffer();
+          body = Buffer.from(arr);
+        } else {
+          output.warn(
+            `  Warning: failed to download signed URL for ${e.kind} '${e.name}': ${res.status}`
+          );
+          continue;
+        }
+      } else {
+        output.warn(
+          `  Warning: ${e.kind} '${e.name}' has no content or signedUrl`
+        );
+        continue;
+      }
+      const dest = resolve(rootDir, e.path);
+      const root = pathResolve(rootDir);
+      const rootWithSep = root.endsWith("/") ? root : `${root}/`;
+      if (dest !== root && !dest.startsWith(rootWithSep)) {
+        output.warn(
+          `  Warning: refusing to write ${e.kind} '${e.name}' outside plugin dir: ${e.path}`
+        );
+        continue;
+      }
+      await mkdir(resolve(dest, ".."), { recursive: true });
+      await writeFile(dest, body);
+    } catch (err) {
+      output.warn(
+        `  Warning: failed to fetch ${e.kind} '${e.name}' (${e.path}): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+}
+async function materializeOfficialExternal(manifest, targetDir) {
+  const r = manifest.redirectTo;
+  if (!r || r.kind !== "github") {
+    throw new Error(
+      `Plugin '${manifest.name}' has unsupported redirectTo (kind=${r?.kind ?? "undefined"}). External plugins must redirect to GitHub.`
+    );
+  }
+  if (!r.owner || !r.repo) {
+    throw new Error(
+      `Plugin '${manifest.name}' has invalid redirectTo: missing owner/repo`
+    );
+  }
+  const url = `https://github.com/${r.owner}/${r.repo}.git`;
+  const cloneTmp = `${targetDir}.${randomUUID()}.clone.tmp`;
+  const args = ["clone", "--depth", "1"];
+  if (r.ref) args.push("--branch", r.ref);
+  args.push("--", url, cloneTmp);
+  try {
+    await runGitClone(args);
+    let sourceDir;
+    if (r.path && r.path.length > 0) {
+      const candidate = resolve(cloneTmp, r.path);
+      const cloneTmpAbs = pathResolve(cloneTmp);
+      const cloneTmpWithSep = cloneTmpAbs.endsWith("/") ? cloneTmpAbs : `${cloneTmpAbs}/`;
+      if (candidate !== cloneTmpAbs && !candidate.startsWith(cloneTmpWithSep)) {
+        throw new Error(`redirectTo.path escapes repo root: '${r.path}'`);
+      }
+      const st = await stat(candidate).catch(() => null);
+      if (!st || !st.isDirectory()) {
+        throw new Error(
+          `redirectTo.path '${r.path}' is not a directory in ${url}`
+        );
+      }
+      sourceDir = candidate;
+    } else {
+      sourceDir = cloneTmp;
+    }
+    await rm(targetDir, { recursive: true, force: true });
+    await mkdir(resolve(targetDir, ".."), { recursive: true });
+    await rename(sourceDir, targetDir);
+    await enrichExternalPluginJson(targetDir, manifest);
+  } catch (err) {
+    await rm(cloneTmp, { recursive: true, force: true }).catch(() => {
+    });
+    throw err;
+  } finally {
+    await rm(cloneTmp, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function enrichExternalPluginJson(pluginDir, manifest) {
+  const pjPath = resolve(pluginDir, ".claude-plugin", "plugin.json");
+  let existing = {};
+  try {
+    const raw = await import("fs/promises").then(
+      (m) => m.readFile(pjPath, "utf8")
+    );
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      existing = parsed;
+    }
+  } catch {
+    await mkdir(resolve(pluginDir, ".claude-plugin"), { recursive: true });
+    existing = {
+      name: manifest.name,
+      version: manifest.version || "1.0.0",
+      description: manifest.description || ""
+    };
+  }
+  let derivedHomepage = manifest.homepage;
+  if (!derivedHomepage && manifest.redirectTo?.kind === "github") {
+    const r = manifest.redirectTo;
+    derivedHomepage = `https://github.com/${r.owner}/${r.repo}`;
+    if (r.path) derivedHomepage += `/tree/${r.ref ?? "main"}/${r.path}`;
+  }
+  if (!existing.author && manifest.author) {
+    existing.author = { ...manifest.author };
+  }
+  if (!existing.homepage && derivedHomepage) {
+    existing.homepage = derivedHomepage;
+  }
+  const ifaceExisting = existing.interface ?? {};
+  const ifaceOut = { ...ifaceExisting };
+  if (!ifaceOut.developerName && manifest.author?.name) {
+    ifaceOut.developerName = manifest.author.name;
+  }
+  if (!ifaceOut.websiteURL && derivedHomepage) {
+    ifaceOut.websiteURL = derivedHomepage;
+  }
+  if (Object.keys(ifaceOut).length > 0) {
+    existing.interface = ifaceOut;
+  }
+  await writeFile(pjPath, `${JSON.stringify(existing, null, 2)}
+`, "utf8");
+}
+async function runGitClone(args) {
+  await new Promise((res, rej) => {
+    const child = spawn("git", args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += typeof chunk === "string" ? chunk : chunk.toString();
+    });
+    child.on("error", (err) => rej(err));
+    child.on("close", (code) => {
+      if (code === 0) res();
+      else
+        rej(
+          new Error(`git ${args.join(" ")} exited ${code}: ${stderr.trim()}`)
+        );
+    });
+  });
+}
+function buildPluginJsonShape(manifest, context) {
+  const out = {
+    name: manifest.name,
+    version: manifest.version || "1.0.0",
+    description: manifest.description
+  };
+  if (Object.keys(context.mcpServers).length > 0) {
+    out.mcpServers = context.mcpServers;
+  }
+  if (manifest.author && Object.keys(manifest.author).length > 0) {
+    out.author = { ...manifest.author };
+  }
+  let homepage = manifest.homepage;
+  if (!homepage && manifest.redirectTo?.kind === "github") {
+    const r = manifest.redirectTo;
+    homepage = `https://github.com/${r.owner}/${r.repo}`;
+    if (r.path) homepage += `/tree/${r.ref ?? "main"}/${r.path}`;
+  }
+  if (homepage) out.homepage = homepage;
+  const ifaceOut = {};
+  if (manifest.author?.name) ifaceOut.developerName = manifest.author.name;
+  if (homepage) ifaceOut.websiteURL = homepage;
+  if (Object.keys(ifaceOut).length > 0) out.interface = ifaceOut;
+  return out;
+}
+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 normalizeMcpServerDefaults(mcpServers) {
+  const result = {};
+  for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+    if (!serverConfig || typeof serverConfig !== "object") {
+      result[serverName] = serverConfig;
+      continue;
+    }
+    const cfg = { ...serverConfig };
+    if (typeof cfg.url === "string" && cfg.url.length > 0 && typeof cfg.command !== "string" && typeof cfg.type !== "string") {
+      cfg.type = "http";
+    }
+    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/commands/marketplace/_codex-content-loader.ts
+function pickContentLoader(resolved, opts = {}) {
+  switch (resolved.source.kind) {
+    case "rush":
+      return buildRushPluginContentLoader(resolved.source, opts);
+    case "directory":
+    case "github":
+      return buildLocalCachePluginContentLoader(resolved);
+    default:
+      return async () => ({});
+  }
+}
+function buildRushPluginContentLoader(source, opts = {}) {
+  const token = opts.token ?? getAuthToken();
+  const fetchOpts = {};
+  if (opts.fetchFn !== void 0) fetchOpts.fetchFn = opts.fetchFn;
+  if (token !== void 0 && token !== null) fetchOpts.token = token;
+  const webBase = inferWebBase(source.host);
+  const fetchFn = opts.fetchFn ?? globalThis.fetch;
+  return async (entry) => {
+    if (typeof entry.name !== "string" || entry.name.length === 0) return {};
+    try {
+      const detail = await fetchRushPlugin(source, entry.name, fetchOpts);
+      const manifest = pickManifestFields(
+        detail
+      );
+      const hasMcp = detail.mcpServers && Object.keys(detail.mcpServers).length > 0;
+      const pluginWebUrl = `${webBase}/next/plugins/${encodeURIComponent(
+        entry.name
+      )}`;
+      const isOfficial = detail.source === "claude-plugins-official";
+      const isGitImported = detail.source === "rush-git-import";
+      const usesOssProxy = isOfficial || isGitImported;
+      const isExternalRedirect = isOfficial && !!detail.redirectTo;
+      const skillEntries = Array.isArray(detail.skills) && detail.skills.length > 0 ? detail.skills.filter(
+        (s) => !!s && typeof s.name === "string" && s.name.length > 0
+      ) : [];
+      const skillsPlaceholders = [];
+      for (const s of skillEntries) {
+        const url = `${webBase}/next/plugins/${encodeURIComponent(entry.name)}`;
+        let rawSkillMd;
+        if (isExternalRedirect) {
+        } else if (usesOssProxy && typeof s.path === "string" && s.path.length > 0) {
+          const skillMdPath = ensureSkillMdSuffix(s.path);
+          try {
+            const file = await fetchRushOfficialFile(
+              source,
+              entry.name,
+              skillMdPath,
+              fetchOpts
+            );
+            if (typeof file.content === "string" && file.content.length > 0) {
+              rawSkillMd = file.content;
+            }
+          } catch {
+          }
+        } else {
+          const mdUrl = `${webBase}/next/skills/${encodeURIComponent(s.name)}.md`;
+          try {
+            const headers = {
+              Accept: "text/markdown,text/plain,*/*"
+            };
+            if (token) headers.Authorization = `Bearer ${token}`;
+            const res = await fetchFn(mdUrl, { headers });
+            if (res.ok) {
+              const text = await res.text();
+              if (text.length > 0) rawSkillMd = text;
+            }
+          } catch {
+          }
+        }
+        skillsPlaceholders.push({
+          name: s.name,
+          url,
+          ...rawSkillMd !== void 0 ? { rawSkillMd } : {}
+        });
+      }
+      return {
+        ...manifest !== void 0 ? { manifest } : {},
+        ...hasMcp ? { mcpServers: detail.mcpServers } : {},
+        ...skillsPlaceholders.length > 0 ? { skillsPlaceholders } : {},
+        pluginWebUrl
+      };
+    } catch {
+      return {};
+    }
+  };
+}
+function inferWebBase(host) {
+  const hostname = host.split(":")[0];
+  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "0.0.0.0") {
+    return `http://${host}`;
+  }
+  return `https://${host}`;
+}
+function buildLocalCachePluginContentLoader(resolved) {
+  return async (entry) => {
+    const relPath = extractLocalPluginPath(entry);
+    if (relPath === null) return {};
+    const pluginDir = pathResolve2(resolved.rootDir, relPath);
+    const root = pathResolve2(resolved.rootDir);
+    const rootWithSep = root.endsWith(sep) ? root : root + sep;
+    const safe = pluginDir === root || pluginDir.startsWith(rootWithSep);
+    if (!safe) return {};
+    let manifest;
+    let mcpServers;
+    let skillsSourceDir;
+    try {
+      const pj = await readFile(
+        pathResolve2(pluginDir, ".claude-plugin", "plugin.json"),
+        "utf8"
+      );
+      const parsed = JSON.parse(pj);
+      manifest = pickManifestFields(parsed);
+      const inline = parsed.mcpServers;
+      if (inline && typeof inline === "object" && !Array.isArray(inline) && Object.keys(inline).length > 0) {
+        mcpServers = inline;
+      }
+    } catch {
+    }
+    try {
+      const raw = await readFile(pathResolve2(pluginDir, ".mcp.json"), "utf8");
+      const parsed = JSON.parse(raw);
+      let servers = null;
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed) && "mcpServers" in parsed && typeof parsed.mcpServers === "object") {
+        servers = parsed.mcpServers;
+      } else if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        servers = parsed;
+      }
+      if (servers && Object.keys(servers).length > 0) {
+        mcpServers = servers;
+      }
+    } catch {
+    }
+    const skillsDir = pathResolve2(pluginDir, "skills");
+    if (await isDir(skillsDir)) {
+      skillsSourceDir = skillsDir;
+    }
+    return {
+      ...manifest !== void 0 ? { manifest } : {},
+      ...mcpServers !== void 0 ? { mcpServers } : {},
+      ...skillsSourceDir !== void 0 ? { skillsSourceDir } : {}
+    };
+  };
+}
+function extractLocalPluginPath(entry) {
+  if (typeof entry.source === "string") {
+    return entry.source;
+  }
+  if (entry.source && typeof entry.source === "object" && !Array.isArray(entry.source)) {
+    const obj = entry.source;
+    if (typeof obj.url === "string" && obj.url.length > 0) {
+      return null;
+    }
+    if (typeof obj.path === "string" && obj.path.length > 0) {
+      return obj.path;
+    }
+  }
+  if (entry.source === void 0 && typeof entry.name === "string" && entry.name.length > 0) {
+    return `plugins/${entry.name}`;
+  }
+  return null;
+}
+async function isDir(p) {
+  try {
+    const s = await stat2(p);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function pathExists(p) {
+  try {
+    await access(p, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pickManifestFields(raw) {
+  const m = {};
+  if (typeof raw.description === "string" && raw.description.length > 0) {
+    m.description = raw.description;
+  }
+  if (typeof raw.version === "string" && raw.version.length > 0) {
+    m.version = raw.version;
+  }
+  if (typeof raw.homepage === "string" && raw.homepage.length > 0) {
+    m.homepage = raw.homepage;
+  }
+  if (typeof raw.license === "string" && raw.license.length > 0) {
+    m.license = raw.license;
+  }
+  if (Array.isArray(raw.keywords)) {
+    const kw = raw.keywords.filter(
+      (x) => typeof x === "string" && x.length > 0
+    );
+    if (kw.length > 0) m.keywords = kw;
+  }
+  if (raw.author && typeof raw.author === "object" && !Array.isArray(raw.author)) {
+    const a = raw.author;
+    const author = {};
+    if (typeof a.name === "string") author.name = a.name;
+    if (typeof a.email === "string") author.email = a.email;
+    if (typeof a.url === "string") author.url = a.url;
+    if (Object.keys(author).length > 0) m.author = author;
+  }
+  if (raw.interface && typeof raw.interface === "object" && !Array.isArray(raw.interface)) {
+    const iface = pickInterfaceFields(raw.interface);
+    if (iface !== void 0) m.interface = iface;
+  }
+  return Object.keys(m).length > 0 ? m : void 0;
+}
+function pickInterfaceFields(raw) {
+  const out = {};
+  const stringKeys = [
+    "displayName",
+    "shortDescription",
+    "longDescription",
+    "developerName",
+    "category",
+    "websiteURL",
+    "privacyPolicyURL",
+    "termsOfServiceURL",
+    "brandColor",
+    "composerIcon",
+    "logo"
+  ];
+  for (const key of stringKeys) {
+    const v = raw[key];
+    if (typeof v === "string" && v.length > 0) {
+      out[key] = v;
+    }
+  }
+  for (const key of ["capabilities", "defaultPrompt", "screenshots"]) {
+    const v = raw[key];
+    if (Array.isArray(v)) {
+      const arr = v.filter(
+        (x) => typeof x === "string" && x.length > 0
+      );
+      if (arr.length > 0) out[key] = arr;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function ensureSkillMdSuffix(p) {
+  if (p.endsWith(".md") || p.endsWith(".MD")) return p;
+  const trimmed = p.endsWith("/") ? p.slice(0, -1) : p;
+  return `${trimmed}/SKILL.md`;
+}
+
+export {
+  fetchRushMarketplace,
+  fetchRushPlugin,
+  materializeRushPlugin,
+  SkillAuthError,
+  pickContentLoader,
+  buildRushPluginContentLoader,
+  buildLocalCachePluginContentLoader,
+  pathExists
+};
+//# sourceMappingURL=chunk-C7KJUHEF.js.map