@schoolai/shipyard 3.7.0 → 3.8.0-rc.20260529.0

package/dist/chunk-L2WQMPWS.js

@@ -1,666 +0,0 @@
-#!/usr/bin/env node
-import {
-  logger
-} from "./chunk-2UN5AR7V.js";
-import {
-  external_exports
-} from "./chunk-VPMN47TL.js";
-
-// src/shared/capabilities/mcp-servers.ts
-import { readFile as readFile2 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-
-// src/shared/mcp/claude-code-credentials.ts
-import { execFile as execFileCb } from "child_process";
-import { readFile } from "fs/promises";
-import { homedir } from "os";
-import { join } from "path";
-import { promisify } from "util";
-
-// src/shared/mcp/schemas.ts
-import {
-  OAuthMetadataSchema,
-  OAuthProtectedResourceMetadataSchema,
-  OpenIdProviderDiscoveryMetadataSchema
-} from "@modelcontextprotocol/sdk/shared/auth.js";
-var AuthorizationServerMetadataSchema = external_exports.union([
-  OAuthMetadataSchema,
-  OpenIdProviderDiscoveryMetadataSchema
-]);
-var DiscoveryStateSchema = external_exports.object({
-  authorizationServerUrl: external_exports.string(),
-  authorizationServerMetadata: AuthorizationServerMetadataSchema.optional(),
-  resourceMetadata: OAuthProtectedResourceMetadataSchema.optional(),
-  resourceMetadataUrl: external_exports.string().optional()
-}).passthrough();
-
-// src/shared/mcp/claude-code-credentials.ts
-var execFile = promisify(execFileCb);
-var ClaudeCodeOAuthEntrySchema = external_exports.object({
-  serverName: external_exports.string().nullable().optional(),
-  serverUrl: external_exports.string().nullable().optional(),
-  clientId: external_exports.string().nullable().optional(),
-  clientSecret: external_exports.string().nullable().optional(),
-  accessToken: external_exports.string().nullable().optional(),
-  refreshToken: external_exports.string().nullable().optional(),
-  expiresAt: external_exports.number().nullable().optional(),
-  discoveryState: DiscoveryStateSchema.nullable().optional()
-}).passthrough();
-var CredentialsFileSchema = external_exports.object({
-  mcpOAuth: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
-}).passthrough();
-var CREDENTIALS_PATH = join(homedir(), ".claude", ".credentials.json");
-var KEYCHAIN_SERVICE = "Claude Code-credentials";
-var PluginMcpJsonSchema = external_exports.record(
-  external_exports.string(),
-  external_exports.object({
-    url: external_exports.string().optional(),
-    oauth: external_exports.object({ clientId: external_exports.string(), callbackPort: external_exports.number().optional() }).optional()
-  }).passthrough()
-);
-async function extractClientIdsFromPlugin(installPath, result) {
-  const raw = await readFile(join(installPath, ".mcp.json"), "utf-8");
-  const json = JSON.parse(raw);
-  const outer = external_exports.record(external_exports.string(), external_exports.unknown()).safeParse(json);
-  if (!outer.success) return;
-  const servers = outer.data.mcpServers ?? outer.data;
-  const validated = PluginMcpJsonSchema.safeParse(servers);
-  if (!validated.success) return;
-  for (const config of Object.values(validated.data)) {
-    if (config.url && config.oauth?.clientId) {
-      result.set(config.url, config.oauth.clientId);
-    }
-  }
-}
-async function readPluginClientIds() {
-  const result = /* @__PURE__ */ new Map();
-  try {
-    const installedPath = join(homedir(), ".claude", "plugins", "installed_plugins.json");
-    const InstalledPluginsSchema = external_exports.object({
-      plugins: external_exports.record(external_exports.string(), external_exports.array(external_exports.object({ installPath: external_exports.string().optional() }))).optional()
-    });
-    const parsed = InstalledPluginsSchema.safeParse(
-      JSON.parse(await readFile(installedPath, "utf-8"))
-    );
-    if (!parsed.success || !parsed.data.plugins) return result;
-    for (const installs of Object.values(parsed.data.plugins)) {
-      const installPath = installs?.[0]?.installPath;
-      if (!installPath) continue;
-      await extractClientIdsFromPlugin(installPath, result).catch(() => {
-      });
-    }
-  } catch {
-  }
-  return result;
-}
-async function readKeychainCredentials() {
-  if (process.platform !== "darwin") return null;
-  try {
-    const { stdout } = await execFile(
-      "security",
-      ["find-generic-password", "-s", KEYCHAIN_SERVICE, "-w"],
-      { timeout: 5e3 }
-    );
-    const result = external_exports.record(external_exports.string(), external_exports.unknown()).safeParse(JSON.parse(stdout.trim()));
-    return result.success ? result.data : null;
-  } catch {
-    return null;
-  }
-}
-function scanEntries(mcpOAuth, serverUrl) {
-  let bestWithToken = null;
-  let clientId;
-  let clientSecret;
-  let discoveryState;
-  for (const value of Object.values(mcpOAuth)) {
-    const entryResult = ClaudeCodeOAuthEntrySchema.safeParse(value);
-    if (!entryResult.success) continue;
-    const entry = entryResult.data;
-    if (entry.serverUrl !== serverUrl) continue;
-    if (entry.clientId && !clientId) {
-      clientId = entry.clientId;
-      clientSecret = entry.clientSecret || void 0;
-    }
-    if (entry.discoveryState && !discoveryState) {
-      discoveryState = entry.discoveryState;
-    }
-    if (entry.accessToken && !bestWithToken) {
-      bestWithToken = entry;
-    }
-  }
-  return { bestWithToken, clientId, clientSecret, discoveryState };
-}
-function findMatchingEntry(credentialsData, serverName, serverUrl) {
-  const fileResult = CredentialsFileSchema.safeParse(credentialsData);
-  if (!fileResult.success) return null;
-  const mcpOAuth = fileResult.data.mcpOAuth;
-  if (!mcpOAuth) return null;
-  const { bestWithToken, clientId, clientSecret, discoveryState } = scanEntries(
-    mcpOAuth,
-    serverUrl
-  );
-  if (!bestWithToken && !clientId) return null;
-  return {
-    serverName: bestWithToken?.serverName ?? serverName,
-    serverUrl,
-    clientId: bestWithToken?.clientId || clientId,
-    clientSecret: bestWithToken?.clientSecret || clientSecret || void 0,
-    accessToken: bestWithToken?.accessToken || void 0,
-    refreshToken: bestWithToken?.refreshToken || void 0,
-    expiresAt: bestWithToken?.expiresAt ?? void 0,
-    discoveryState: bestWithToken?.discoveryState ?? discoveryState ?? void 0
-  };
-}
-async function readClaudeCodeCredentials(serverName, serverUrl) {
-  if (!serverUrl) return null;
-  try {
-    const keychainData = await readKeychainCredentials();
-    if (keychainData) {
-      const entry = findMatchingEntry(keychainData, serverName, serverUrl);
-      if (entry) {
-        logger.debug({ serverUrl }, "Found Claude Code credentials in macOS Keychain");
-        return entry;
-      }
-    }
-  } catch (err) {
-    logger.debug({ err }, "Failed to read Claude Code credentials from Keychain");
-  }
-  try {
-    const raw = await readFile(CREDENTIALS_PATH, "utf-8");
-    const fileResult = CredentialsFileSchema.safeParse(JSON.parse(raw));
-    if (fileResult.success) {
-      const entry = findMatchingEntry(fileResult.data, serverName, serverUrl);
-      if (entry) {
-        logger.debug({ serverUrl }, "Found Claude Code credentials in legacy file");
-        return entry;
-      }
-    }
-    return null;
-  } catch (err) {
-    logger.debug({ err }, "Failed to read Claude Code credentials from file");
-    return null;
-  }
-}
-
-// src/shared/mcp/resolve-servers.ts
-var ENV_VAR_PATTERN = /\$\{([^}]+)\}/g;
-var VAULT_REF_PATTERN = /^\$\{vault:([^}]+)\}$/;
-function interpolateEnvVars(headers) {
-  const result = {};
-  for (const [key, value] of Object.entries(headers)) {
-    result[key] = value.replace(
-      ENV_VAR_PATTERN,
-      (_, varName) => process.env[varName] ?? ""
-    );
-  }
-  return result;
-}
-function resolveHeaders(server) {
-  if (!server.headers) return void 0;
-  return interpolateEnvVars(server.headers);
-}
-function resolveStdioEnv(env, store, log) {
-  if (!env) return void 0;
-  if (!store) return env;
-  const result = {};
-  let changed = false;
-  for (const [key, value] of Object.entries(env)) {
-    const match = VAULT_REF_PATTERN.exec(value);
-    if (match) {
-      const vaultKey = match[1] ?? "";
-      const token = store.getTokenSync(vaultKey);
-      if (token && !store.isExpired(token)) {
-        result[key] = token.accessToken;
-        changed = true;
-        log?.({
-          event: "vault_ref_resolved",
-          envKey: key,
-          vaultKey,
-          tokenType: token.tokenType,
-          hasExpiry: token.expiresAt !== void 0
-        });
-        continue;
-      }
-      log?.({
-        event: "vault_ref_unresolved",
-        envKey: key,
-        vaultKey,
-        tokenFound: token !== null,
-        tokenExpired: token ? store.isExpired(token) : false
-      });
-    }
-    result[key] = value;
-  }
-  return changed ? result : env;
-}
-function resolveEnabledMcpServers(overrides, available, mcpTokenStore) {
-  if (!overrides || !available) return void 0;
-  const enabledNames = new Set(overrides.filter((o) => o.enabled).map((o) => o.name));
-  if (enabledNames.size === 0) return {};
-  const result = {};
-  for (const server of available) {
-    if (!enabledNames.has(server.name)) continue;
-    if (server.type === "http" && server.url) {
-      result[server.name] = {
-        type: "http",
-        url: server.url,
-        headers: resolveHeaders(server)
-      };
-    } else if (server.type === "sse" && server.url) {
-      result[server.name] = {
-        type: "sse",
-        url: server.url,
-        headers: resolveHeaders(server)
-      };
-    } else if (server.command) {
-      result[server.name] = {
-        command: server.command,
-        args: server.args ?? void 0,
-        env: resolveStdioEnv(server.env, mcpTokenStore)
-      };
-    }
-  }
-  return result;
-}
-
-// src/shared/auth/anthropic-credentials.ts
-import { execFile as execFileCb2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var execFile2 = promisify2(execFileCb2);
-var defaultLog = (entry) => logger.debug(entry, entry.event);
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-async function readKeychainEntry(service) {
-  if (process.platform !== "darwin") return null;
-  try {
-    const { stdout } = await execFile2("security", ["find-generic-password", "-s", service, "-w"], {
-      timeout: 5e3
-    });
-    const value = stdout.trim();
-    return value || null;
-  } catch {
-    return null;
-  }
-}
-async function readKeychainOAuthToken(log = defaultLog) {
-  if (process.platform !== "darwin") {
-    log({ event: "anthropic_keychain_read_skipped", reason: "non_darwin" });
-    return null;
-  }
-  const raw = await readKeychainEntry("Claude Code-credentials");
-  if (!raw) {
-    log({ event: "anthropic_keychain_oauth_missing", reason: "no_credentials_entry" });
-    return null;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    log({ event: "anthropic_keychain_oauth_corrupt", reason: "json_parse_error" });
-    return null;
-  }
-  if (!isRecord(parsed)) {
-    log({ event: "anthropic_keychain_oauth_corrupt", reason: "json_parse_error" });
-    return null;
-  }
-  const oauth = parsed.claudeAiOauth;
-  if (!isRecord(oauth)) {
-    log({ event: "anthropic_keychain_oauth_missing", reason: "no_oauth_field" });
-    return null;
-  }
-  const token = oauth.accessToken;
-  if (typeof token !== "string" || token.length === 0) {
-    log({ event: "anthropic_keychain_oauth_missing", reason: "no_oauth_field" });
-    return null;
-  }
-  return token;
-}
-async function readKeychainManagedKey() {
-  const value = await readKeychainEntry("Claude Code");
-  if (!value || !value.startsWith("sk-")) return null;
-  return value;
-}
-
-// src/shared/capabilities/account-integrations.ts
-function parseClaudeAiServers(data) {
-  if (typeof data !== "object" || data === null) return [];
-  const obj = data;
-  if (!Array.isArray(obj.data)) return [];
-  const results = [];
-  for (const entry of obj.data) {
-    if (typeof entry !== "object" || entry === null) continue;
-    const rec = entry;
-    if (typeof rec.name === "string" && typeof rec.url === "string") {
-      results.push({ name: rec.name, url: rec.url });
-    }
-  }
-  return results;
-}
-async function fetchClaudeAiIntegrations(log) {
-  const debugLog = log ?? ((entry) => logger.debug(entry, entry.event));
-  try {
-    const token = await readKeychainOAuthToken(debugLog);
-    if (!token) {
-      debugLog({ event: "claudeai_integrations_skipped", reason: "no_oauth_token" });
-      return [];
-    }
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 1e4);
-    try {
-      const response = await fetch("https://api.anthropic.com/v1/mcp_servers?limit=1000", {
-        headers: {
-          Authorization: `Bearer ${token}`
-        },
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        debugLog({
-          event: "claudeai_integrations_fetch_failed",
-          status: response.status
-        });
-        return [];
-      }
-      const body = await response.json();
-      const servers = parseClaudeAiServers(body);
-      return servers.map((s) => ({
-        name: s.name,
-        type: "http",
-        url: s.url,
-        enabled: true,
-        source: "claudeai",
-        authStatus: "unknown"
-      }));
-    } finally {
-      clearTimeout(timeout);
-    }
-  } catch (err) {
-    debugLog({
-      event: "claudeai_integrations_fetch_error",
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return [];
-  }
-}
-
-// src/shared/capabilities/mcp-servers.ts
-var MCPStdioEntrySchema = external_exports.object({
-  type: external_exports.literal("stdio").optional(),
-  command: external_exports.string(),
-  args: external_exports.array(external_exports.string()).optional(),
-  env: external_exports.record(external_exports.string(), external_exports.string()).optional()
-}).passthrough();
-var MCPOAuthConfigSchema = external_exports.object({
-  clientId: external_exports.string().optional(),
-  callbackPort: external_exports.number().optional()
-}).passthrough();
-var MCPHttpEntrySchema = external_exports.object({
-  type: external_exports.literal("http"),
-  url: external_exports.string(),
-  headers: external_exports.record(external_exports.string(), external_exports.string()).optional(),
-  oauth: MCPOAuthConfigSchema.optional()
-}).passthrough();
-var MCPSSEEntrySchema = external_exports.object({
-  type: external_exports.literal("sse"),
-  url: external_exports.string(),
-  headers: external_exports.record(external_exports.string(), external_exports.string()).optional()
-}).passthrough();
-var MCPServerEntrySchema = external_exports.union([MCPStdioEntrySchema, MCPHttpEntrySchema, MCPSSEEntrySchema]);
-function shouldFetchClaudeAiIntegrations(preferredAuth) {
-  if (preferredAuth == null) return true;
-  return preferredAuth === "claude-ai";
-}
-var SECRET_PATTERNS = /^(sk-|ghp_|gho_|glpat-|xoxb-|xoxp-|Bearer\s|token\s)/i;
-var SECRET_FLAGS = /* @__PURE__ */ new Set(["--api-key", "--token", "--secret", "--password", "--key", "-k"]);
-function redactArgs(args) {
-  return args.map((arg, i) => {
-    if (SECRET_PATTERNS.test(arg)) return "***";
-    const prevArg = i > 0 ? args[i - 1] : void 0;
-    if (prevArg && SECRET_FLAGS.has(prevArg)) return "***";
-    const eqIdx = arg.indexOf("=");
-    if (eqIdx > 0 && SECRET_FLAGS.has(arg.slice(0, eqIdx))) {
-      return `${arg.slice(0, eqIdx + 1)}***`;
-    }
-    return arg;
-  });
-}
-function redactEnv(env) {
-  const result = {};
-  for (const key of Object.keys(env)) {
-    result[key] = "***";
-  }
-  return result;
-}
-function isHttpEntry(data) {
-  return "type" in data && data.type === "http";
-}
-function isSSEEntry(data) {
-  return "type" in data && data.type === "sse";
-}
-function entryToServerInfo(name, data, source) {
-  if (isHttpEntry(data)) {
-    return {
-      name,
-      type: "http",
-      url: data.url,
-      headers: data.headers,
-      oauth: data.oauth,
-      enabled: true,
-      source,
-      authStatus: "unknown"
-    };
-  }
-  if (isSSEEntry(data)) {
-    return {
-      name,
-      type: "sse",
-      url: data.url,
-      headers: data.headers,
-      enabled: true,
-      source,
-      authStatus: "unknown"
-    };
-  }
-  return {
-    name,
-    type: "stdio",
-    command: data.command,
-    args: data.args,
-    env: data.env,
-    enabled: true,
-    source,
-    authStatus: "unknown"
-  };
-}
-async function readMCPConfig(filePath, source, log) {
-  try {
-    const raw = await readFile2(filePath, "utf-8");
-    const json = JSON.parse(raw);
-    const entries = typeof json.mcpServers === "object" && json.mcpServers !== null ? json.mcpServers : json;
-    const servers = [];
-    for (const [name, value] of Object.entries(entries)) {
-      if (name === "mcpServers") continue;
-      if (typeof value !== "object" || value === null || Array.isArray(value)) continue;
-      const result = MCPServerEntrySchema.safeParse(value);
-      if (!result.success) {
-        const entry = {
-          event: "mcp_config_entry_invalid",
-          name,
-          source,
-          filePath,
-          error: result.error.message
-        };
-        if (log) log(entry);
-        else console.warn("[mcp-servers]", entry.event, entry.name, entry.error);
-        continue;
-      }
-      servers.push(entryToServerInfo(name, result.data, source));
-    }
-    return servers;
-  } catch {
-    return [];
-  }
-}
-async function readPluginMCPServers() {
-  const servers = [];
-  try {
-    const settingsPath = join2(homedir2(), ".claude", "settings.json");
-    const settingsRaw = await readFile2(settingsPath, "utf-8");
-    const settings = JSON.parse(settingsRaw);
-    if (!settings.enabledPlugins) return [];
-    const installedPath = join2(homedir2(), ".claude", "plugins", "installed_plugins.json");
-    const installedRaw = await readFile2(installedPath, "utf-8");
-    const installed = JSON.parse(installedRaw);
-    if (!installed.plugins) return [];
-    for (const [pluginId, enabled] of Object.entries(settings.enabledPlugins)) {
-      if (!enabled) continue;
-      const installs = installed.plugins[pluginId];
-      if (!installs || installs.length === 0) continue;
-      const installPath = installs[0]?.installPath;
-      if (!installPath) continue;
-      const mcpJsonPath = join2(installPath, ".mcp.json");
-      const pluginServers = await readMCPConfig(mcpJsonPath, "plugin");
-      servers.push(...pluginServers);
-    }
-  } catch {
-  }
-  return servers;
-}
-var SOURCE_PRIORITY = [
-  "claudeai",
-  "plugin",
-  "user",
-  "project",
-  "local",
-  "mcp-json"
-];
-async function resolveClaudeCodeAuthStatuses(servers) {
-  for (const server of servers.values()) {
-    if (server.authStatus !== "unknown") continue;
-    if (server.type === "stdio") continue;
-    const ccCreds = await readClaudeCodeCredentials(server.name, server.url ?? "");
-    if (ccCreds?.accessToken && ccCreds.expiresAt && ccCreds.expiresAt > Date.now()) {
-      server.authStatus = "authenticated";
-    }
-  }
-}
-function resolveStdioAuthStatus(server, tokens, tokenStore) {
-  if (!server.env) return;
-  for (const value of Object.values(server.env)) {
-    const match = VAULT_REF_PATTERN.exec(value);
-    if (!match) continue;
-    const vaultKey = match[1] ?? "";
-    const token = tokens[vaultKey];
-    if (token) {
-      server.authStatus = tokenStore.isExpired(token) ? "unauthenticated" : "authenticated";
-      return;
-    }
-  }
-}
-async function resolveAuthStatuses(servers, tokenStore) {
-  const tokens = await tokenStore.getAllTokens();
-  for (const server of servers.values()) {
-    if (server.type === "stdio") {
-      resolveStdioAuthStatus(server, tokens, tokenStore);
-      continue;
-    }
-    const token = tokens[server.name];
-    if (token) {
-      server.authStatus = tokenStore.isExpired(token) ? "unauthenticated" : "authenticated";
-    }
-  }
-  await resolveClaudeCodeAuthStatuses(servers);
-}
-async function detectMCPServers(environments, tokenStore, log, lastKnown, preferredAuth) {
-  try {
-    return await detectMCPServersInner(environments, tokenStore, log, preferredAuth);
-  } catch (err) {
-    const { logger: logger2 } = await import("./logger-GQCSLSZH.js");
-    if (lastKnown && lastKnown.length > 0) {
-      logger2.warn(
-        { err, lastKnownCount: lastKnown.length },
-        "detectMCPServers threw \u2014 preserving lastKnown"
-      );
-      return lastKnown;
-    }
-    logger2.debug({ err }, "detectMCPServers threw with no lastKnown \u2014 returning []");
-    return [];
-  }
-}
-async function detectMCPServersInner(environments, tokenStore, log, preferredAuth) {
-  const allServers = [];
-  const userSettingsPath = join2(homedir2(), ".claude", "settings.json");
-  const userLocalSettingsPath = join2(homedir2(), ".claude", "settings.local.json");
-  const userMcpJsonPath = join2(homedir2(), ".mcp.json");
-  const userClaudeJsonPath = join2(homedir2(), ".claude.json");
-  const fetchClaudeAi = shouldFetchClaudeAiIntegrations(preferredAuth);
-  const claudeAiPromise = fetchClaudeAi ? fetchClaudeAiIntegrations(log) : Promise.resolve([]);
-  if (!fetchClaudeAi && log) {
-    log({ event: "claudeai_integrations_skipped_by_method", method: preferredAuth ?? null });
-  }
-  const [
-    userServers,
-    userLocalServers,
-    userMcpJsonServers,
-    userClaudeJsonServers,
-    pluginServers,
-    claudeAiServers
-  ] = await Promise.all([
-    readMCPConfig(userSettingsPath, "user", log),
-    readMCPConfig(userLocalSettingsPath, "user", log),
-    readMCPConfig(userMcpJsonPath, "user", log),
-    readMCPConfig(userClaudeJsonPath, "user", log),
-    readPluginMCPServers(),
-    claudeAiPromise
-  ]);
-  allServers.push(
-    ...claudeAiServers,
-    ...pluginServers,
-    ...userServers,
-    ...userLocalServers,
-    ...userMcpJsonServers,
-    ...userClaudeJsonServers
-  );
-  const envResults = await Promise.all(
-    environments.map((env) => {
-      const projectPath = join2(env.path, ".claude", "settings.json");
-      const localPath = join2(env.path, ".claude", "settings.local.json");
-      const mcpJsonPath = join2(env.path, ".mcp.json");
-      return Promise.all([
-        readMCPConfig(projectPath, "project", log),
-        readMCPConfig(localPath, "local", log),
-        readMCPConfig(mcpJsonPath, "mcp-json", log)
-      ]);
-    })
-  );
-  for (const [projectServers, localServers, mcpJsonServers] of envResults) {
-    allServers.push(...projectServers, ...localServers, ...mcpJsonServers);
-  }
-  const deduped = /* @__PURE__ */ new Map();
-  for (const server of allServers) {
-    const existing = deduped.get(server.name);
-    if (!existing || SOURCE_PRIORITY.indexOf(server.source) >= SOURCE_PRIORITY.indexOf(existing.source)) {
-      deduped.set(server.name, server);
-    }
-  }
-  if (tokenStore) {
-    await resolveAuthStatuses(deduped, tokenStore);
-  }
-  return [...deduped.values()];
-}
-
-export {
-  DiscoveryStateSchema,
-  readPluginClientIds,
-  readClaudeCodeCredentials,
-  resolveStdioEnv,
-  resolveEnabledMcpServers,
-  readKeychainOAuthToken,
-  readKeychainManagedKey,
-  shouldFetchClaudeAiIntegrations,
-  redactArgs,
-  redactEnv,
-  detectMCPServers
-};
-//# sourceMappingURL=chunk-L2WQMPWS.js.map