@agentdocumentformat/cli 0.7.2

package/dist/chunks/chunk-GEKSJHIV.mjs

@@ -0,0 +1,2472 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  require_jsx_runtime
+} from "./chunk-7CV2SA3H.mjs";
+import {
+  WELCOME_OVERLAY
+} from "./chunk-I3UYSITV.mjs";
+import {
+  cjs
+} from "./chunk-SGUTYISF.mjs";
+import {
+  mcp_config_exports
+} from "./chunk-VMHTYDH4.mjs";
+import {
+  Box_default,
+  Text
+} from "./chunk-3AT7IIP7.mjs";
+import {
+  useTheme
+} from "./chunk-EYX2YLJW.mjs";
+import {
+  require_react
+} from "./chunk-6GJ4QHRI.mjs";
+import {
+  adapter_registry_exports
+} from "./chunk-UYY5M2PB.mjs";
+import {
+  external_exports
+} from "./chunk-ZJKXHM4Q.mjs";
+import {
+  __export,
+  __toESM
+} from "./chunk-M2RX3S2T.mjs";
+
+// src/main/tui/ui/KeyHint.tsx
+var import_react2 = __toESM(require_react(), 1);
+
+// src/main/tui/app/keys.tsx
+var import_react = __toESM(require_react(), 1), import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
+function elementRect(element) {
+  if (!element?.yogaNode) return null;
+  let x = 0, y = 0;
+  for (let node = element; node; node = node.parentNode)
+    node.yogaNode && (x += node.yogaNode.getComputedLeft(), y += node.yogaNode.getComputedTop());
+  return { x, y, width: element.yogaNode.getComputedWidth(), height: element.yogaNode.getComputedHeight() };
+}
+function rectContains(rect, x, y) {
+  return !!rect && x >= rect.x && x < rect.x + rect.width && y >= rect.y && y < rect.y + rect.height;
+}
+function createKeyRouter() {
+  let bindings = [], wheels = [], clicks = [], nextId = 1;
+  return {
+    registerClick(binding) {
+      return clicks.push(binding), () => {
+        let index = clicks.indexOf(binding);
+        index >= 0 && clicks.splice(index, 1);
+      };
+    },
+    click(event) {
+      let best = null;
+      for (let binding of clicks) {
+        if (!binding.active.current) continue;
+        let rect = elementRect(binding.ref.current);
+        if (!rect || !rectContains(rect, event.x, event.y)) continue;
+        let area = rect.width * rect.height;
+        (!best || area <= best.area) && (best = { binding, area });
+      }
+      return best ? best.binding.handler.current(event) === !0 : !1;
+    },
+    registerWheel(binding) {
+      return wheels.push(binding), () => {
+        let index = wheels.indexOf(binding);
+        index >= 0 && wheels.splice(index, 1);
+      };
+    },
+    wheel(event, context) {
+      let best = null;
+      for (let binding of wheels) {
+        if (!binding.active.current || binding.layer === "overlay" !== context.overlayOpen) continue;
+        let rect = elementRect(binding.ref.current);
+        if (!rect || !rectContains(rect, event.x, event.y)) continue;
+        let area = rect.width * rect.height;
+        (!best || area <= best.area) && (best = { binding, area });
+      }
+      return !best || event.delta === 0 ? !!best : (best.binding.handler.current(event.delta, event), !0);
+    },
+    register(layer, handler, active) {
+      let binding = { id: nextId++, layer, handler, active };
+      return bindings.push(binding), () => {
+        let index = bindings.indexOf(binding);
+        index >= 0 && bindings.splice(index, 1);
+      };
+    },
+    dispatch(input, key, context) {
+      let order = context.overlayOpen ? ["overlay", "global"] : context.focus === "input" || context.focus === "tabs" ? [context.focus, "global"] : [context.focus, "view", "global"];
+      for (let layer of order) {
+        let candidates = bindings.filter((b) => b.layer === layer && b.active.current);
+        for (let i = candidates.length - 1; i >= 0; i--)
+          if (candidates[i].handler.current(input, key) === !0) return !0;
+      }
+      return !1;
+    }
+  };
+}
+var KeyRouterContext = (0, import_react.createContext)(null);
+function KeyRouterProvider({ router, children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(KeyRouterContext.Provider, { value: router, children });
+}
+function useKeyRouter() {
+  let router = (0, import_react.useContext)(KeyRouterContext);
+  if (!router) throw new Error("useKeys must be used inside the TUI shell");
+  return router;
+}
+function useKeys(handler, options) {
+  let router = useKeyRouter(), handlerRef = (0, import_react.useRef)(handler), activeRef = (0, import_react.useRef)(options.active !== !1);
+  handlerRef.current = handler, activeRef.current = options.active !== !1, (0, import_react.useEffect)(() => router.register(options.layer, handlerRef, activeRef), [router, options.layer]);
+}
+var WHEEL_STEP = 3;
+function useWheel(ref, onWheel, options = {}) {
+  let router = useKeyRouter(), handler = (0, import_react.useRef)(onWheel), active = (0, import_react.useRef)(options.active !== !1);
+  handler.current = onWheel, active.current = options.active !== !1;
+  let layer = options.layer ?? "main";
+  (0, import_react.useEffect)(() => router.registerWheel({ layer, ref, handler, active }), [router, layer, ref]);
+}
+function useClick(ref, onClick, options = {}) {
+  let router = useKeyRouter(), handler = (0, import_react.useRef)(onClick), active = (0, import_react.useRef)(options.active !== !1);
+  handler.current = onClick, active.current = options.active !== !1, (0, import_react.useEffect)(() => router.registerClick({ ref, handler, active }), [router, ref]);
+}
+function keyLabel(spec) {
+  let parts = spec.split("+"), ctrl = parts.some((p) => p.toLowerCase() === "ctrl");
+  return parts.map((part) => {
+    let p = part.toLowerCase();
+    return p === "ctrl" ? "Ctrl+" : p === "alt" || p === "meta" ? "Alt+" : p === "shift" ? "Shift+" : p === "cmd" || p === "super" ? "Cmd+" : p === "backspace" ? "Backspace" : p === "delete" || p === "del" ? "Delete" : p === "home" ? "Home" : p === "end" ? "End" : p === "enter" || p === "return" ? "Enter" : p === "esc" || p === "escape" ? "Esc" : p === "tab" ? "Tab" : p === "up" ? "\u2191" : p === "down" ? "\u2193" : p === "left" ? "\u2190" : p === "right" ? "\u2192" : p === "pgup" || p === "pageup" ? "PgUp" : p === "pgdn" || p === "pagedown" ? "PgDn" : part.length === 1 && ctrl ? part.toUpperCase() : part;
+  }).join("");
+}
+
+// src/main/tui/ui/KeyHint.tsx
+var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
+function KeyHint({ keys, label }) {
+  let theme = useTheme();
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Text, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { bold: !0, color: theme.color.accent, children: keys.split(" ").map(keyLabel).join("/") }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Text, { color: theme.color.muted, children: [
+      " ",
+      label
+    ] })
+  ] });
+}
+function KeyHints({ hints }) {
+  let theme = useTheme();
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { wrap: "truncate-end", children: hints.map((hint, index) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react2.Fragment, { children: [
+    index > 0 ? /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Text, { color: theme.color.dim, children: [
+      " ",
+      theme.glyph.sep,
+      " "
+    ] }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(KeyHint, { ...hint })
+  ] }, `${hint.keys}:${hint.label}`)) });
+}
+
+// src/main/tui/identity/model.ts
+var IDENTITY_OVERLAY = "identity", NEW_AGENT_OVERLAY = "new-agent", IDENTITY_BANNER_KEY = "shell.identity.banner";
+var SAVED_WORD = "saved";
+function shortDid(did, keep = 6) {
+  if (!did) return "";
+  let m = did.match(/^(did:[a-z0-9]+:)(.*)$/i);
+  if (!m) return did.length > 16 ? `${did.slice(0, 10)}\u2026${did.slice(-4)}` : did;
+  let id = m[2];
+  return id.length > keep + 5 ? `${m[1]}${id.slice(0, keep)}\u2026${id.slice(-4)}` : did;
+}
+function normalizePhrase(text) {
+  return phraseWords(text).join(" ");
+}
+function phraseWords(text) {
+  return text.toLowerCase().split(/[\s,;]+/).map((w) => w.replace(/^\d+[.):-]?$/, "").replace(/^\d+[.):-]/, "").replace(/[^a-z]/g, "")).filter(Boolean);
+}
+function isLoopbackUrl(url) {
+  try {
+    let host = new URL(url).hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    return host === "localhost" || host === "::1" || /^127\./.test(host) || host.startsWith("::ffff:127.");
+  } catch {
+    return !1;
+  }
+}
+var LOOPBACK_ONLY_TEXT = "The seed phrase and passphrase never travel over the network: create, restore and unlock only work from the daemon\u2019s own machine. Run the terminal app (`adf`) or `adf identity` there.", IDENTITY_EXPLAINER = "Your owner identity proves these agents are yours. It is 12 words: the same words restore it anywhere, in the terminal or in ADF Studio.";
+function identityErrorText(code, fallback, identity) {
+  switch (code) {
+    case "invalid_mnemonic":
+      return "Those are not 12 valid seed words. Check each word and the order.";
+    case "owner_mismatch":
+      return identity?.ownerDid ? `That phrase belongs to a different owner. This machine\u2019s owner is ${shortDid(identity.ownerDid)}: enter its phrase. (To switch owners, import the new phrase in ADF Studio.)` : "That phrase belongs to a different owner than this machine\u2019s.";
+    case "wrong_passphrase":
+      return "Wrong passphrase.";
+    case "weak_passphrase":
+      return "Choose a passphrase of at least 8 characters.";
+    case "passphrase_required":
+      return "This machine keeps the identity in a passphrase-protected file: enter the passphrase.";
+    case "loopback_only":
+      return LOOPBACK_ONLY_TEXT;
+    case "identity_exists":
+      return "An owner identity already exists here; nothing was created.";
+    case "nothing_to_unlock":
+      return "There is nothing to unlock yet: create or restore an identity.";
+    default:
+      return fallback;
+  }
+}
+function identityBadge(identity) {
+  if (!identity) return null;
+  switch (identity.status) {
+    case "ready":
+      return identity.backupConfirmed ? { text: `owner ${shortDid(identity.ownerDid, 4).replace(/^did:key:/, "")}`, tone: "muted" } : { text: `owner ${shortDid(identity.ownerDid, 4).replace(/^did:key:/, "")} not backed up`, tone: "warn" };
+    case "locked":
+      return { text: "owner locked", tone: "warn" };
+    case "restore-needed":
+      return { text: "owner: restore", tone: "warn" };
+    default:
+      return { text: "no owner", tone: "warn" };
+  }
+}
+function onboardingLines(identity) {
+  switch (identity.status) {
+    case "locked":
+      return { title: "Your owner identity is locked", next: "Unlock it with its passphrase to create and seal agents." };
+    case "restore-needed":
+      return {
+        title: "Restore your owner identity",
+        next: `This machine already belongs to ${shortDid(identity.ownerDid)}: enter the 12-word phrase for this owner.`
+      };
+    case "ready":
+      return { title: "Owner identity ready", next: "" };
+    default:
+      return { title: "Set up your owner identity", next: "Create a new one, or restore yours from its 12-word seed phrase." };
+  }
+}
+function onboardingChoices(identity) {
+  switch (identity.status) {
+    case "none":
+      return [
+        { key: "c", label: "Create new", mode: "create" },
+        { key: "r", label: "Restore from seed phrase", mode: "restore" }
+      ];
+    case "restore-needed":
+      return [{ key: "r", label: "Restore from seed phrase", mode: "restore" }];
+    case "locked":
+      return identity.storage === "file" && identity.passphraseRequired ? [{ key: "u", label: "Unlock with passphrase", mode: "unlock" }] : [];
+    default:
+      return [];
+  }
+}
+function passphraseProblem(first, second, isNew) {
+  return first ? isNew ? first.length < 8 ? "At least 8 characters." : second !== null && first !== second ? "The two passphrases differ. Type them again." : null : null : "Enter the passphrase.";
+}
+
+// src/main/tui/identity/Onboarding.tsx
+var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
+function openIdentity(store, props = {}) {
+  store.actions.pushOverlay({ kind: IDENTITY_OVERLAY, props: { ...props } });
+}
+function openNewAgent(store, name) {
+  let identity = store.getState().identity;
+  if (identity && identity.status !== "ready") {
+    openIdentity(store, { mode: "status", then: NEW_AGENT_OVERLAY, name, reason: "Agents are sealed under your owner identity: set it up first, then the new agent follows." });
+    return;
+  }
+  store.actions.pushOverlay({ kind: NEW_AGENT_OVERLAY, props: name ? { name } : {} });
+}
+function bannerKeyOf(identity) {
+  return `${identity.status}:${identity.backupConfirmed ? 1 : 0}`;
+}
+function needsAttention(identity) {
+  return !!identity && (identity.status !== "ready" || !identity.backupConfirmed);
+}
+function identityKey(store, identity, input, panel) {
+  if (!identity) return !1;
+  if (input === "i")
+    return openIdentity(store), !0;
+  if (input === "I" && !panel && needsAttention(identity))
+    return store.actions.setViewState(IDENTITY_BANNER_KEY, bannerKeyOf(identity)), !0;
+  if (!panel) return !1;
+  let choice = onboardingChoices(identity).find((c) => c.key === input);
+  return choice ? (openIdentity(store, { mode: choice.mode }), !0) : !1;
+}
+function IdentityOnboarding({ identity, width, focused }) {
+  let theme = useTheme(), { title, next } = onboardingLines(identity), choices = onboardingChoices(identity), inner = Math.max(30, Math.min(width - 2, 72));
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(Box_default, { flexDirection: "column", width: inner, marginTop: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(Text, { bold: !0, color: theme.color.accent, children: [
+      theme.glyph.wordmark,
+      " ",
+      title
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { children: " " }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { wrap: "wrap", color: theme.color.text, children: IDENTITY_EXPLAINER }),
+    next ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { wrap: "wrap", color: theme.color.muted, children: next }) : null,
+    identity.status === "locked" && choices.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { wrap: "wrap", color: theme.color.warn, children: identity.message }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { children: " " }),
+    choices.map((c) => /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(Text, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(Text, { bold: !0, color: theme.color.accent, children: [
+        "  [",
+        c.key,
+        "]"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(Text, { color: theme.color.text, children: [
+        " ",
+        c.label
+      ] })
+    ] }, c.key)),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { children: " " }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(KeyHints, { hints: focused ? [{ keys: "i", label: "details" }, { keys: "o", label: "load an existing .adf" }] : [{ keys: "shift+tab", label: "focus here to choose" }] })
+  ] });
+}
+function IdentityBanner({ identity, width }) {
+  let theme = useTheme(), text = identity.status === "ready" ? `Seed phrase backup not confirmed for ${shortDid(identity.ownerDid, 4)}. Make sure the 12 words are written down.` : identity.status === "locked" ? "Owner identity locked: new agents cannot be created until it is unlocked." : identity.status === "restore-needed" ? `Restore owner ${shortDid(identity.ownerDid, 4)} from its 12 words to create agents here.` : "No owner identity yet: set one up to create agents.";
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(Text, { wrap: "truncate-end", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(Text, { color: theme.color.warn, children: [
+      theme.glyph.warn,
+      " ",
+      text.slice(0, Math.max(10, width - 24))
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { color: theme.color.dim, children: "  " }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { bold: !0, color: theme.color.accent, children: "i" }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { color: theme.color.muted, children: " open" }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(Text, { color: theme.color.dim, children: [
+      " ",
+      theme.glyph.sep,
+      " "
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { bold: !0, color: theme.color.accent, children: "I" }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { color: theme.color.muted, children: " hide" })
+  ] });
+}
+
+// src/main/tui/setup/channels.ts
+var { ADAPTER_REGISTRY } = cjs(adapter_registry_exports), CHANNELS_OVERLAY = "channels", CHANNEL_ORDER = ["telegram", "discord", "slack", "email", "whatsapp"];
+function channelEntries() {
+  let byType = new Map(ADAPTER_REGISTRY.map((e) => [e.type, e]));
+  return CHANNEL_ORDER.map((t) => byType.get(t)).filter((e) => !!e);
+}
+function findChannel(type) {
+  if (!type) return;
+  let wanted = type.trim().toLowerCase();
+  return channelEntries().find((e) => e.type === wanted || e.displayName.toLowerCase() === wanted);
+}
+function credentialFields(entry) {
+  return entry.credentials ?? [
+    ...entry.requiredEnvKeys.map((key) => ({ key, label: key, required: !0 })),
+    ...(entry.optionalEnvKeys ?? []).map((key) => ({ key, label: key, required: !1 }))
+  ];
+}
+var DEFAULT_ADAPTER_CONFIG = { enabled: !0, policy: { dm: "all", groups: "mention" } }, SHAPES = {
+  TELEGRAM_BOT_TOKEN: { test: /^\d{5,}:[A-Za-z0-9_-]{30,}$/, message: "A bot token looks like 123456789:AA\u2026 (digits, a colon, then 30+ characters)." },
+  DISCORD_BOT_TOKEN: { test: /^[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{20,}$/, message: "A Discord bot token has three dot-separated parts (Bot page \u2192 Reset Token)." },
+  DISCORD_APPLICATION_ID: { test: /^\d{15,22}$/, message: "The application ID is a long number (General Information page)." },
+  SLACK_APP_TOKEN: { test: /^xapp-/, message: "The app-level token starts with xapp- (Socket Mode page)." },
+  SLACK_BOT_TOKEN: { test: /^xoxb-/, message: "The bot token starts with xoxb- (Install App page)." },
+  EMAIL_USERNAME: { test: /^[^\s@]+@[^\s@]+\.[^\s@]+$/, message: "Enter the full email address." }
+};
+function validateCredentials(entry, values) {
+  let errors = {};
+  for (let field of credentialFields(entry)) {
+    let value = (values[field.key] ?? "").trim();
+    if (!value) {
+      field.required && (errors[field.key] = `${field.label} is required.`);
+      continue;
+    }
+    if (/\s/.test(value)) {
+      errors[field.key] = "No spaces: paste the value exactly.";
+      continue;
+    }
+    let shape = SHAPES[field.key];
+    shape && !shape.test.test(value) && (errors[field.key] = shape.message);
+  }
+  return errors;
+}
+function adapterLiveState(diag, type) {
+  let state = diag?.states?.find((s) => s.type === type);
+  return state ? { status: ["connected", "connecting", "disconnected", "error"].includes(state.status) ? state.status : "unknown", ...state.error ? { error: state.error } : {} } : { status: diag?.configured?.some((c) => c.type === type) ? "not running" : "unknown" };
+}
+function configuredChannels(config) {
+  return Object.keys(config?.adapters ?? {});
+}
+
+// src/shared/constants/provider-catalog.ts
+var provider_catalog_exports = {};
+__export(provider_catalog_exports, {
+  PROVIDER_CATALOG: () => PROVIDER_CATALOG,
+  PROVIDER_CATALOG_GROUPS: () => PROVIDER_CATALOG_GROUPS,
+  catalogEntryForProvider: () => catalogEntryForProvider,
+  findCatalogEntry: () => findCatalogEntry,
+  isSubscriptionType: () => isSubscriptionType,
+  nextProviderName: () => nextProviderName,
+  providerTypeHint: () => providerTypeHint
+});
+var PROVIDER_CATALOG_GROUPS = [
+  { id: "subscription", label: "Subscriptions", hint: "Sign in with an existing consumer plan. No API key." },
+  { id: "api", label: "APIs", hint: "Pay-as-you-go endpoints. Paste an API key." },
+  { id: "local", label: "Local", hint: "Servers running on this machine. Usually no key." },
+  { id: "other", label: "Other", hint: "Anything that speaks the OpenAI API." }
+], oc = (key, label, baseUrl, description, extra = {}) => ({
+  key,
+  label,
+  type: "openai-compatible",
+  group: "api",
+  baseUrl,
+  description,
+  keyPlaceholder: "API key",
+  modelPlaceholder: "model id",
+  ...extra
+}), local = (key, label, baseUrl, description, extra = {}) => ({
+  key,
+  label,
+  type: "openai-compatible",
+  group: "local",
+  baseUrl,
+  description,
+  keyPlaceholder: "Usually not needed",
+  modelPlaceholder: "loaded model id",
+  keyOptional: !0,
+  ...extra
+}), PROVIDER_CATALOG = [
+  // ---- Subscriptions --------------------------------------------------------
+  {
+    key: "chatgpt-subscription",
+    label: "ChatGPT",
+    type: "chatgpt-subscription",
+    group: "subscription",
+    description: "Use your ChatGPT Plus / Pro plan. Sign in with your OpenAI account.",
+    modelPlaceholder: "e.g. gpt-5.6-sol",
+    iconKey: "openai"
+  },
+  {
+    key: "grok-subscription",
+    label: "Grok",
+    type: "grok-subscription",
+    group: "subscription",
+    description: "Use your SuperGrok or X Premium plan. Sign in with xAI.",
+    modelPlaceholder: "e.g. grok-4.5",
+    iconKey: "x"
+  },
+  // ---- First-party APIs -----------------------------------------------------
+  {
+    key: "anthropic",
+    label: "Anthropic",
+    type: "anthropic",
+    group: "api",
+    description: "Claude models via the Anthropic API.",
+    keyPlaceholder: "sk-ant-...",
+    modelPlaceholder: "e.g. claude-sonnet-4-5",
+    iconKey: "anthropic",
+    keysUrl: "https://console.anthropic.com/settings/keys"
+  },
+  {
+    key: "openai",
+    label: "OpenAI",
+    type: "openai",
+    group: "api",
+    description: "GPT and o-series models via the OpenAI API.",
+    keyPlaceholder: "sk-...",
+    modelPlaceholder: "e.g. gpt-4o, o3-mini",
+    iconKey: "openai",
+    keysUrl: "https://platform.openai.com/api-keys"
+  },
+  {
+    key: "openrouter",
+    label: "OpenRouter",
+    type: "openrouter",
+    group: "api",
+    description: "One key for hundreds of models across providers.",
+    keyPlaceholder: "sk-or-...",
+    modelPlaceholder: "e.g. anthropic/claude-sonnet-4",
+    iconKey: "openrouter",
+    keysUrl: "https://openrouter.ai/keys"
+  },
+  // ---- OpenAI-compatible hosted APIs ---------------------------------------
+  oc("gemini", "Google Gemini", "https://generativelanguage.googleapis.com/v1beta/openai", "Gemini models through the OpenAI-compatible endpoint.", { iconKey: "gemini", keysUrl: "https://aistudio.google.com/apikey", modelPlaceholder: "e.g. gemini-2.5-pro" }),
+  oc("xai", "xAI", "https://api.x.ai/v1", "Grok models via the xAI API.", { iconKey: "x", keysUrl: "https://console.x.ai", modelPlaceholder: "e.g. grok-4" }),
+  oc("mistral", "Mistral", "https://api.mistral.ai/v1", "Mistral and Codestral models.", { iconKey: "mistral", keysUrl: "https://console.mistral.ai/api-keys", modelPlaceholder: "e.g. mistral-large-latest" }),
+  oc("deepseek", "DeepSeek", "https://api.deepseek.com/v1", "DeepSeek chat and reasoner models.", { iconKey: "deepseek", keysUrl: "https://platform.deepseek.com/api_keys", modelPlaceholder: "e.g. deepseek-chat" }),
+  oc("groq", "Groq", "https://api.groq.com/openai/v1", "Fast inference for open models on LPUs.", { keysUrl: "https://console.groq.com/keys", modelPlaceholder: "e.g. llama-3.3-70b-versatile" }),
+  oc("cerebras", "Cerebras", "https://api.cerebras.ai/v1", "Very fast inference for open models.", { keysUrl: "https://cloud.cerebras.ai", modelPlaceholder: "e.g. llama-3.3-70b" }),
+  oc("together", "Together AI", "https://api.together.xyz/v1", "Open models, fine-tunes, and dedicated endpoints.", { keysUrl: "https://api.together.ai/settings/api-keys", modelPlaceholder: "e.g. meta-llama/Llama-3.3-70B-Instruct-Turbo" }),
+  oc("fireworks", "Fireworks AI", "https://api.fireworks.ai/inference/v1", "Fast serverless inference for open models.", { keysUrl: "https://fireworks.ai/account/api-keys", modelPlaceholder: "e.g. accounts/fireworks/models/llama-v3p3-70b-instruct" }),
+  oc("perplexity", "Perplexity", "https://api.perplexity.ai", "Sonar models with built-in web search.", { iconKey: "perplexity", keysUrl: "https://www.perplexity.ai/settings/api", modelPlaceholder: "e.g. sonar-pro" }),
+  oc("cohere", "Cohere", "https://api.cohere.ai/compatibility/v1", "Command models through the compatibility API.", { keysUrl: "https://dashboard.cohere.com/api-keys", modelPlaceholder: "e.g. command-a-03-2025" }),
+  oc("huggingface", "Hugging Face", "https://router.huggingface.co/v1", "Inference Providers router. Uses your HF token.", { iconKey: "huggingface", keysUrl: "https://huggingface.co/settings/tokens", keyPlaceholder: "hf_...", modelPlaceholder: "e.g. meta-llama/Llama-3.3-70B-Instruct" }),
+  oc("nvidia", "NVIDIA NIM", "https://integrate.api.nvidia.com/v1", "Hosted NIM endpoints on build.nvidia.com.", { iconKey: "nvidia", keysUrl: "https://build.nvidia.com", keyPlaceholder: "nvapi-...", modelPlaceholder: "e.g. meta/llama-3.3-70b-instruct" }),
+  oc("vercel-ai-gateway", "Vercel AI Gateway", "https://ai-gateway.vercel.sh/v1", "Route to many providers through one Vercel key.", { iconKey: "vercel", keysUrl: "https://vercel.com/dashboard/ai-gateway", modelPlaceholder: "e.g. anthropic/claude-sonnet-4" }),
+  oc("cloudflare", "Cloudflare Workers AI", "https://api.cloudflare.com/client/v4/accounts/YOUR_ACCOUNT_ID/ai/v1", "Open models at the edge. Replace YOUR_ACCOUNT_ID in the base URL.", { iconKey: "cloudflare", keysUrl: "https://dash.cloudflare.com/profile/api-tokens", modelPlaceholder: "e.g. @cf/meta/llama-3.3-70b-instruct-fp8-fast" }),
+  oc("azure-openai", "Azure OpenAI", "https://YOUR_RESOURCE.openai.azure.com/openai/v1", "Azure-hosted OpenAI models. Replace YOUR_RESOURCE in the base URL.", { keysUrl: "https://portal.azure.com", modelPlaceholder: "your deployment name" }),
+  oc("deepinfra", "DeepInfra", "https://api.deepinfra.com/v1/openai", "Low-cost hosting for open models.", { keysUrl: "https://deepinfra.com/dash/api_keys", modelPlaceholder: "e.g. meta-llama/Llama-3.3-70B-Instruct" }),
+  oc("sambanova", "SambaNova", "https://api.sambanova.ai/v1", "Fast inference on SambaNova RDUs.", { keysUrl: "https://cloud.sambanova.ai/apis", modelPlaceholder: "e.g. Meta-Llama-3.3-70B-Instruct" }),
+  oc("nebius", "Nebius", "https://api.studio.nebius.com/v1", "Nebius AI Studio open-model endpoints.", { keysUrl: "https://studio.nebius.com/settings/api-keys", modelPlaceholder: "e.g. meta-llama/Llama-3.3-70B-Instruct" }),
+  oc("hyperbolic", "Hyperbolic", "https://api.hyperbolic.xyz/v1", "Open models on decentralized GPU capacity.", { keysUrl: "https://app.hyperbolic.xyz/settings", modelPlaceholder: "e.g. meta-llama/Llama-3.3-70B-Instruct" }),
+  oc("novita", "Novita AI", "https://api.novita.ai/v3/openai", "Serverless open-model inference.", { keysUrl: "https://novita.ai/settings/key-management", modelPlaceholder: "e.g. meta-llama/llama-3.3-70b-instruct" }),
+  oc("baseten", "Baseten", "https://inference.baseten.co/v1", "Model APIs and dedicated deployments.", { keysUrl: "https://app.baseten.co/settings/api_keys", modelPlaceholder: "e.g. deepseek-ai/DeepSeek-V3-0324" }),
+  oc("scaleway", "Scaleway", "https://api.scaleway.ai/v1", "EU-hosted generative APIs.", { iconKey: "scaleway", keysUrl: "https://console.scaleway.com/iam/api-keys", modelPlaceholder: "e.g. llama-3.3-70b-instruct" }),
+  oc("venice", "Venice", "https://api.venice.ai/api/v1", "Private, uncensored open-model inference.", { keysUrl: "https://venice.ai/settings/api", modelPlaceholder: "e.g. llama-3.3-70b" }),
+  oc("kluster", "kluster.ai", "https://api.kluster.ai/v1", "Open-model inference with batch pricing.", { keysUrl: "https://platform.kluster.ai/apikeys", modelPlaceholder: "e.g. deepseek-ai/DeepSeek-V3-0324" }),
+  oc("moonshot", "Moonshot (Kimi)", "https://api.moonshot.ai/v1", "Kimi models from Moonshot AI.", { iconKey: "kimi", keysUrl: "https://platform.moonshot.ai/console/api-keys", modelPlaceholder: "e.g. kimi-k2-0711-preview" }),
+  oc("zai", "Z.ai (GLM)", "https://api.z.ai/api/paas/v4", "GLM models from Zhipu / Z.ai.", { keysUrl: "https://z.ai/manage-apikey/apikey-list", modelPlaceholder: "e.g. glm-4.5" }),
+  oc("qwen", "Qwen (Alibaba)", "https://dashscope-intl.aliyuncs.com/compatible-mode/v1", "Qwen models via Model Studio (international).", { iconKey: "qwen", keysUrl: "https://modelstudio.console.alibabacloud.com/?tab=playground#/api-key", modelPlaceholder: "e.g. qwen-plus" }),
+  oc("minimax", "MiniMax", "https://api.minimax.io/v1", "MiniMax text models.", { iconKey: "minimax", keysUrl: "https://platform.minimax.io/user-center/basic-information/interface-key", modelPlaceholder: "e.g. MiniMax-M1" }),
+  oc("inception", "Inception", "https://api.inceptionlabs.ai/v1", "Mercury diffusion language models.", { keysUrl: "https://platform.inceptionlabs.ai", modelPlaceholder: "e.g. mercury-coder" }),
+  // ---- Local servers ---------------------------------------------------------
+  local("lmstudio", "LM Studio", "http://localhost:1234/v1", "Local server from the LM Studio app.", { iconKey: "lmstudio" }),
+  local("ollama", "Ollama", "http://localhost:11434/v1", "Local models served by Ollama.", { iconKey: "ollama", modelPlaceholder: "e.g. llama3.3" }),
+  local("vllm", "vLLM", "http://localhost:8000/v1", "vLLM OpenAI-compatible server.", { iconKey: "vllm" }),
+  local("llamacpp", "llama.cpp", "http://localhost:8080/v1", "llama-server from llama.cpp."),
+  local("litellm", "LiteLLM", "http://localhost:4000/v1", "LiteLLM proxy in front of any provider.", { keyOptional: !1, keyPlaceholder: "Proxy key, if set" }),
+  local("jan", "Jan", "http://localhost:1337/v1", "Local server from the Jan app."),
+  local("localai", "LocalAI", "http://localhost:8080/v1", "LocalAI drop-in OpenAI server."),
+  local("tgwui", "text-generation-webui", "http://localhost:5000/v1", "oobabooga OpenAI extension."),
+  // ---- Other -----------------------------------------------------------------
+  {
+    key: "openai-compatible",
+    label: "OpenAI-compatible",
+    type: "openai-compatible",
+    group: "other",
+    description: "Any endpoint that speaks the OpenAI chat API. Enter the base URL.",
+    keyPlaceholder: "Optional",
+    modelPlaceholder: "model id"
+  }
+], BY_KEY = new Map(PROVIDER_CATALOG.map((e) => [e.key, e]));
+function findCatalogEntry(key) {
+  return key ? BY_KEY.get(key) : void 0;
+}
+function catalogEntryForProvider(p) {
+  return findCatalogEntry(p.preset) ?? findCatalogEntry(p.type);
+}
+function nextProviderName(label, existing) {
+  let taken = new Set(existing.map((p) => p.name.trim().toLowerCase()));
+  if (!taken.has(label.toLowerCase())) return label;
+  for (let n = 2; n < 1e3; n++) {
+    let candidate = `${label} ${n}`;
+    if (!taken.has(candidate.toLowerCase())) return candidate;
+  }
+  return `${label} ${Date.now()}`;
+}
+function providerTypeHint(type) {
+  switch (type) {
+    case "anthropic":
+      return "Anthropic API";
+    case "openai":
+      return "OpenAI API";
+    case "openrouter":
+      return "OpenRouter API";
+    case "openai-compatible":
+      return "OpenAI-compatible API";
+    case "chatgpt-subscription":
+      return "ChatGPT subscription (OAuth)";
+    case "grok-subscription":
+      return "Grok subscription (OAuth)";
+  }
+}
+function isSubscriptionType(type) {
+  return type === "chatgpt-subscription" || type === "grok-subscription";
+}
+
+// src/main/tui/setup/provider.ts
+var { PROVIDER_CATALOG: PROVIDER_CATALOG2 } = cjs(provider_catalog_exports), PROVIDER_OVERLAY = "provider.add", API_TYPES = /* @__PURE__ */ new Set(["anthropic", "openai", "openrouter", "openai-compatible"]);
+function providerRows() {
+  let order = { subscription: 0, api: 1, local: 2, other: 3 };
+  return [...PROVIDER_CATALOG2].filter((e) => e.group === "subscription" || API_TYPES.has(e.type)).sort((a, b) => (order[a.group] ?? 9) - (order[b.group] ?? 9)).map((entry) => ({
+    entry,
+    ...entry.type === "chatgpt-subscription" ? { signIn: "chatgpt" } : entry.type === "grok-subscription" ? { signIn: "grok" } : {}
+  }));
+}
+function findProviderRow(key) {
+  if (!key) return;
+  let wanted = key.trim().toLowerCase();
+  return providerRows().find((r) => r.entry.key === wanted || r.entry.label.toLowerCase() === wanted || r.entry.type === wanted);
+}
+function keyOptional(entry) {
+  return entry.keyOptional === !0 || entry.group === "other";
+}
+function needsBaseUrl(entry) {
+  return entry.type === "openai-compatible";
+}
+function validateProvider(entry, v) {
+  let errors = {};
+  if (needsBaseUrl(entry)) {
+    let url = v.baseUrl.trim();
+    if (!url) errors.baseUrl = "The server\u2019s base URL, e.g. http://localhost:11434/v1.";
+    else if (/YOUR_[A-Z_]+/.test(url)) errors.baseUrl = "Replace the YOUR_\u2026 part of the URL with your own value.";
+    else
+      try {
+        let parsed = new URL(url);
+        parsed.protocol !== "http:" && parsed.protocol !== "https:" && (errors.baseUrl = "Use an http(s) URL.");
+      } catch {
+        errors.baseUrl = "Not a URL.";
+      }
+  }
+  let key = v.apiKey.trim();
+  return !key && !keyOptional(entry) ? errors.apiKey = "Paste the API key." : /\s/.test(key) && (errors.apiKey = "No spaces: paste the key exactly."), errors;
+}
+function providerInput(entry, v) {
+  let key = v.apiKey.trim();
+  return {
+    type: entry.type,
+    name: v.name.trim() || entry.label,
+    ...needsBaseUrl(entry) ? { baseUrl: v.baseUrl.trim() } : {},
+    ...v.defaultModel.trim() ? { defaultModel: v.defaultModel.trim() } : {},
+    preset: entry.key,
+    ...key ? { apiKey: key } : {}
+  };
+}
+function keyStorageText(storage) {
+  return storage === "file" ? "the daemon\u2019s passphrase-protected secret file" : "the OS keychain";
+}
+
+// src/shared/constants/mcp-registry.ts
+var mcp_registry_exports = {};
+__export(mcp_registry_exports, {
+  BUNDLED_REGISTRY_UPDATED_AT: () => BUNDLED_REGISTRY_UPDATED_AT,
+  HOST_ONLY_REGISTRY_ENTRY_NAMES: () => HOST_ONLY_REGISTRY_ENTRY_NAMES,
+  MCP_REGISTRY: () => MCP_REGISTRY,
+  REGISTRY_ARG_PLACEHOLDER_RE: () => REGISTRY_ARG_PLACEHOLDER_RE,
+  findEntryIn: () => findEntryIn,
+  findRegistryEntry: () => findRegistryEntry,
+  findRegistryEntryByName: () => findRegistryEntryByName,
+  findRegistryEntryByPypiPackage: () => findRegistryEntryByPypiPackage,
+  findRegistryEntryByUrl: () => findRegistryEntryByUrl,
+  hasUnresolvedPlaceholderArgs: () => hasUnresolvedPlaceholderArgs,
+  registrationFromRegistryEntry: () => registrationFromRegistryEntry,
+  registryEntryRunLocation: () => registryEntryRunLocation
+});
+
+// mcp-registry.json
+var mcp_registry_default = {
+  $notes: "Curated registry of well-known MCP servers, maintained per docs/design/mcp-registry-expansion.md. Never map an entry to the name-squatted packages: PyPI mcp-gmail / telegram-mcp / mcp-server-milvus, npm mcp-filesystem-server / github-mcp-server \u2014 they squat well-known project names but are unrelated (or hostile) third parties.",
+  schemaVersion: 1,
+  updatedAt: "2026-08-25",
+  entries: [
+    {
+      name: "filesystem",
+      displayName: "Filesystem",
+      npmPackage: "@modelcontextprotocol/server-filesystem",
+      args: [
+        "{directory}"
+      ],
+      description: "Read, write, and manage local files and directories",
+      category: "tools",
+      requiredEnvKeys: [],
+      repo: "https://github.com/modelcontextprotocol/servers/blob/main/src/filesystem",
+      runLocation: "host",
+      verified: !0
+    },
+    {
+      name: "playwright",
+      displayName: "Playwright Browser",
+      npmPackage: "@playwright/mcp",
+      description: "Maintained browser automation that attaches to the agent's persistent visible Chromium session",
+      category: "tools",
+      requiredEnvKeys: [],
+      repo: "https://github.com/microsoft/playwright-mcp",
+      verified: !0
+    },
+    {
+      name: "sequential-thinking",
+      displayName: "Sequential Thinking",
+      npmPackage: "@modelcontextprotocol/server-sequential-thinking",
+      description: "Dynamic, reflective problem-solving through thought sequences",
+      category: "tools",
+      requiredEnvKeys: [],
+      repo: "https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking",
+      verified: !0
+    },
+    {
+      name: "markitdown",
+      displayName: "MarkItDown",
+      pypiPackage: "markitdown-mcp",
+      runtime: "python",
+      description: "Convert documents (PDF, Office, images, audio) to Markdown",
+      category: "tools",
+      requiredEnvKeys: [],
+      repo: "https://github.com/microsoft/markitdown",
+      runLocation: "host",
+      verified: !0
+    },
+    {
+      name: "pandoc",
+      displayName: "Pandoc",
+      iconKey: "pandoc",
+      pypiPackage: "mcp-pandoc",
+      runtime: "python",
+      description: "Convert documents between Markdown, HTML, DOCX, PDF, EPUB, and more",
+      category: "tools",
+      requiredEnvKeys: [],
+      repo: "https://github.com/vivekVells/mcp-pandoc",
+      runLocation: "host",
+      verified: !1,
+      prerequisite: "Needs the pandoc binary installed where the server runs (host run recommended; PDF output additionally needs TeX)."
+    },
+    {
+      name: "brave-search",
+      displayName: "Brave Search",
+      iconKey: "brave",
+      npmPackage: "@brave/brave-search-mcp-server",
+      description: "Search the web using Brave Search API",
+      category: "search",
+      requiredEnvKeys: [
+        "BRAVE_API_KEY"
+      ],
+      repo: "https://github.com/brave/brave-search-mcp-server",
+      verified: !0
+    },
+    {
+      name: "context7",
+      displayName: "Context7",
+      npmPackage: "@upstash/context7-mcp",
+      description: "Up-to-date, version-specific library documentation and code examples",
+      category: "search",
+      requiredEnvKeys: [],
+      repo: "https://github.com/upstash/context7",
+      verified: !0
+    },
+    {
+      name: "tavily",
+      displayName: "Tavily",
+      npmPackage: "tavily-mcp",
+      description: "AI-optimized web search, extract, map, and crawl via the Tavily API",
+      category: "search",
+      requiredEnvKeys: [
+        "TAVILY_API_KEY"
+      ],
+      repo: "https://github.com/tavily-ai/tavily-mcp",
+      verified: !0
+    },
+    {
+      name: "exa",
+      displayName: "Exa",
+      npmPackage: "exa-mcp-server",
+      description: "Neural web search and content retrieval via the Exa API",
+      category: "search",
+      requiredEnvKeys: [
+        "EXA_API_KEY"
+      ],
+      repo: "https://github.com/exa-labs/exa-mcp-server",
+      verified: !0
+    },
+    {
+      name: "perplexity",
+      displayName: "Perplexity",
+      iconKey: "perplexity",
+      npmPackage: "@perplexity-ai/mcp-server",
+      description: "Web search, research, and reasoning via the Perplexity Sonar API",
+      category: "search",
+      requiredEnvKeys: [
+        "PERPLEXITY_API_KEY"
+      ],
+      repo: "https://github.com/perplexityai/modelcontextprotocol",
+      verified: !0
+    },
+    {
+      name: "kagi",
+      displayName: "Kagi Search",
+      iconKey: "kagi",
+      pypiPackage: "kagimcp",
+      runtime: "python",
+      description: "Search the web using the Kagi Search API",
+      category: "search",
+      requiredEnvKeys: [
+        "KAGI_API_KEY"
+      ],
+      repo: "https://github.com/kagisearch/kagi-mcp",
+      verified: !0,
+      prerequisite: "Needs a Kagi account with Search API access; the server pins Python 3.12."
+    },
+    {
+      name: "aws-docs",
+      displayName: "AWS Documentation",
+      pypiPackage: "awslabs.aws-documentation-mcp-server",
+      runtime: "python",
+      description: "Search, read, and get recommendations from AWS documentation",
+      category: "search",
+      requiredEnvKeys: [],
+      repo: "https://github.com/awslabs/mcp",
+      verified: !0
+    },
+    {
+      name: "deepwiki",
+      displayName: "DeepWiki",
+      url: "https://mcp.deepwiki.com/mcp",
+      description: "Ask questions about any public GitHub repository via DeepWiki",
+      category: "search",
+      requiredEnvKeys: [],
+      repo: "https://docs.devin.ai/work-with-devin/deepwiki-mcp",
+      verified: !0
+    },
+    {
+      name: "microsoft-learn",
+      displayName: "Microsoft Learn",
+      url: "https://learn.microsoft.com/api/mcp",
+      description: "Search and fetch official Microsoft and Azure documentation and code samples",
+      category: "search",
+      requiredEnvKeys: [],
+      repo: "https://github.com/microsoftdocs/mcp",
+      verified: !0
+    },
+    {
+      name: "cloudflare-docs",
+      displayName: "Cloudflare Docs",
+      iconKey: "cloudflare",
+      url: "https://docs.mcp.cloudflare.com/mcp",
+      description: "Search Cloudflare developer documentation",
+      category: "search",
+      requiredEnvKeys: [],
+      repo: "https://github.com/cloudflare/mcp-server-cloudflare",
+      verified: !0
+    },
+    {
+      name: "duckduckgo",
+      displayName: "DuckDuckGo",
+      iconKey: "duckduckgo",
+      pypiPackage: "duckduckgo-mcp-server",
+      runtime: "python",
+      description: "Zero-key web search via DuckDuckGo with built-in client-side rate limiting",
+      category: "search",
+      requiredEnvKeys: [],
+      repo: "https://github.com/nickclyde/duckduckgo-mcp-server",
+      verified: !1
+    },
+    {
+      name: "serper",
+      displayName: "Serper",
+      pypiPackage: "serper-mcp-server",
+      runtime: "python",
+      description: "Google results (web, images, news, maps, scholar) via the Serper.dev API",
+      category: "search",
+      requiredEnvKeys: [
+        "SERPER_API_KEY"
+      ],
+      repo: "https://github.com/garylab/serper-mcp-server",
+      verified: !1
+    },
+    {
+      name: "searxng",
+      displayName: "SearXNG",
+      iconKey: "searxng",
+      npmPackage: "mcp-searxng",
+      description: "Meta-search through a SearXNG instance, plus URL reading",
+      category: "search",
+      requiredEnvKeys: [
+        "SEARXNG_URL"
+      ],
+      optionalEnvKeys: [
+        "AUTH_USERNAME",
+        "AUTH_PASSWORD"
+      ],
+      repo: "https://github.com/ihor-sokoliuk/mcp-searxng",
+      verified: !1,
+      prerequisite: "Needs a reachable SearXNG instance with the JSON output format enabled."
+    },
+    {
+      name: "arxiv",
+      displayName: "arXiv",
+      iconKey: "arxiv",
+      pypiPackage: "arxiv-mcp-server",
+      runtime: "python",
+      description: "Search, download, and read arXiv papers",
+      category: "search",
+      requiredEnvKeys: [],
+      repo: "https://github.com/blazickjp/arxiv-mcp-server",
+      verified: !1
+    },
+    {
+      name: "fetch",
+      displayName: "Fetch",
+      pypiPackage: "mcp-server-fetch",
+      runtime: "python",
+      description: "Fetch web pages and convert them to markdown for reading",
+      category: "web",
+      requiredEnvKeys: [],
+      repo: "https://github.com/modelcontextprotocol/servers/tree/main/src/fetch",
+      verified: !0,
+      prerequisite: "Can reach local and internal addresses (SSRF-capable) \u2014 the container run location is the safe default."
+    },
+    {
+      name: "firecrawl",
+      displayName: "Firecrawl",
+      npmPackage: "firecrawl-mcp",
+      description: "Web scraping, crawling, and structured extraction via the Firecrawl API",
+      category: "web",
+      requiredEnvKeys: [
+        "FIRECRAWL_API_KEY"
+      ],
+      optionalEnvKeys: [
+        "FIRECRAWL_API_URL"
+      ],
+      repo: "https://github.com/firecrawl/firecrawl-mcp-server",
+      verified: !0
+    },
+    {
+      name: "apify",
+      displayName: "Apify",
+      npmPackage: "@apify/actors-mcp-server",
+      description: "Run Apify Actors for web scraping and automation at scale",
+      category: "web",
+      requiredEnvKeys: [
+        "APIFY_TOKEN"
+      ],
+      repo: "https://github.com/apify/apify-mcp-server",
+      verified: !0
+    },
+    {
+      name: "oxylabs",
+      displayName: "Oxylabs",
+      pypiPackage: "oxylabs-mcp",
+      runtime: "python",
+      description: "Proxy-backed web scraping (universal, Google, Amazon) via Oxylabs",
+      category: "web",
+      requiredEnvKeys: [
+        "OXYLABS_USERNAME",
+        "OXYLABS_PASSWORD"
+      ],
+      repo: "https://github.com/oxylabs/oxylabs-mcp",
+      verified: !0,
+      prerequisite: "Needs a paid Oxylabs account with Web Scraper API access."
+    },
+    {
+      name: "youtube-transcript",
+      displayName: "YouTube Transcript",
+      npmPackage: "@kimtaeyoon83/mcp-server-youtube-transcript",
+      description: "Fetch transcripts and captions for YouTube videos",
+      category: "web",
+      requiredEnvKeys: [],
+      repo: "https://github.com/kimtaeyoon83/mcp-server-youtube-transcript",
+      verified: !1,
+      prerequisite: "YouTube may block datacenter IPs \u2014 if transcript fetches fail from a container, run on host."
+    },
+    {
+      name: "github",
+      displayName: "GitHub",
+      iconKey: "github",
+      url: "https://api.githubcopilot.com/mcp/",
+      oauth: !0,
+      bearerTokenEnvVar: "GITHUB_PERSONAL_ACCESS_TOKEN",
+      description: "Official GitHub remote server \u2014 repositories, issues, pull requests, and actions",
+      category: "dev",
+      requiredEnvKeys: [
+        "GITHUB_PERSONAL_ACCESS_TOKEN"
+      ],
+      repo: "https://github.com/github/github-mcp-server",
+      verified: !0,
+      prerequisite: "Needs a GitHub personal access token (github.com/settings/tokens) scoped to the repositories it should reach."
+    },
+    {
+      name: "git",
+      displayName: "Git",
+      pypiPackage: "mcp-server-git",
+      runtime: "python",
+      description: "Inspect and operate on local Git repositories (repository path is passed per tool call)",
+      category: "dev",
+      requiredEnvKeys: [],
+      repo: "https://github.com/modelcontextprotocol/servers/tree/main/src/git",
+      runLocation: "host",
+      verified: !0
+    },
+    {
+      name: "sentry",
+      displayName: "Sentry",
+      iconKey: "sentry",
+      npmPackage: "@sentry/mcp-server",
+      description: "Query Sentry issues, events, and projects",
+      category: "dev",
+      requiredEnvKeys: [
+        "SENTRY_ACCESS_TOKEN"
+      ],
+      optionalEnvKeys: [
+        "SENTRY_HOST"
+      ],
+      repo: "https://github.com/getsentry/sentry-mcp",
+      verified: !0
+    },
+    {
+      name: "sentry-remote",
+      displayName: "Sentry (remote)",
+      iconKey: "sentry",
+      url: "https://mcp.sentry.dev/mcp",
+      oauth: !0,
+      description: "Official Sentry remote server \u2014 issues, events, releases, and projects via browser OAuth",
+      category: "dev",
+      requiredEnvKeys: [],
+      repo: "https://github.com/getsentry/sentry-mcp",
+      verified: !0,
+      prerequisite: "Sign in to Sentry in your browser on first connect \u2014 no token to paste."
+    },
+    {
+      name: "supabase-remote",
+      displayName: "Supabase (remote)",
+      iconKey: "supabase",
+      url: "https://mcp.supabase.com/mcp",
+      oauth: !0,
+      description: "Official Supabase remote server \u2014 database, auth, storage, and edge functions via browser OAuth",
+      category: "dev",
+      requiredEnvKeys: [],
+      repo: "https://github.com/supabase-community/supabase-mcp",
+      verified: !0,
+      prerequisite: "Sign in to Supabase in your browser on first connect \u2014 no token to paste."
+    },
+    {
+      name: "supabase",
+      displayName: "Supabase",
+      iconKey: "supabase",
+      npmPackage: "@supabase/mcp-server-supabase",
+      description: "Manage Supabase projects: database, auth, storage, and edge functions",
+      category: "dev",
+      requiredEnvKeys: [
+        "SUPABASE_ACCESS_TOKEN"
+      ],
+      repo: "https://github.com/supabase-community/supabase-mcp",
+      verified: !0
+    },
+    {
+      name: "semgrep",
+      displayName: "Semgrep",
+      pypiPackage: "semgrep-mcp",
+      runtime: "python",
+      description: "Static-analysis security scanning of code with Semgrep",
+      category: "dev",
+      requiredEnvKeys: [],
+      repo: "https://github.com/semgrep/mcp",
+      runLocation: "host",
+      verified: !0
+    },
+    {
+      name: "chrome-devtools",
+      displayName: "Chrome DevTools",
+      iconKey: "chrome",
+      npmPackage: "chrome-devtools-mcp",
+      description: "Drive and debug Chrome via the DevTools protocol \u2014 performance traces, network, console",
+      category: "dev",
+      requiredEnvKeys: [],
+      repo: "https://github.com/ChromeDevTools/chrome-devtools-mcp",
+      runLocation: "host",
+      verified: !0,
+      prerequisite: "Drives a local Chrome installation \u2014 run on host with Chrome installed."
+    },
+    {
+      name: "shopify-dev",
+      displayName: "Shopify Dev",
+      iconKey: "shopify",
+      npmPackage: "@shopify/dev-mcp",
+      description: "Shopify developer docs and API schema exploration (zero-config, docs only)",
+      category: "dev",
+      requiredEnvKeys: [],
+      repo: "https://github.com/Shopify/dev-mcp",
+      verified: !0
+    },
+    {
+      name: "gitlab",
+      displayName: "GitLab",
+      iconKey: "gitlab",
+      npmPackage: "@zereight/mcp-gitlab",
+      description: "GitLab projects, issues, merge requests, pipelines, and wikis",
+      category: "dev",
+      requiredEnvKeys: [
+        "GITLAB_API_URL",
+        "GITLAB_PERSONAL_ACCESS_TOKEN"
+      ],
+      optionalEnvKeys: [
+        "GITLAB_PERMISSION_MODE"
+      ],
+      repo: "https://github.com/zereight/gitlab-mcp",
+      verified: !1,
+      prerequisite: "Set GITLAB_API_URL to your instance API base (https://gitlab.com/api/v4 for gitlab.com) and use a personal access token."
+    },
+    {
+      name: "n8n",
+      displayName: "n8n",
+      iconKey: "n8n",
+      npmPackage: "n8n-mcp",
+      description: "n8n node documentation, workflow building, and optional workflow management",
+      category: "dev",
+      requiredEnvKeys: [],
+      optionalEnvKeys: [
+        "N8N_API_URL",
+        "N8N_API_KEY"
+      ],
+      repo: "https://github.com/czlonkowski/n8n-mcp",
+      verified: !1,
+      prerequisite: "Documentation tools work with no configuration; managing workflows needs your n8n instance URL and API key."
+    },
+    {
+      name: "memory",
+      displayName: "Memory",
+      npmPackage: "@modelcontextprotocol/server-memory",
+      description: "Persistent knowledge graph memory for agents",
+      category: "data",
+      requiredEnvKeys: [],
+      repo: "https://github.com/modelcontextprotocol/servers/blob/main/src/memory",
+      verified: !0
+    },
+    {
+      name: "mongodb",
+      displayName: "MongoDB",
+      iconKey: "mongodb",
+      npmPackage: "mongodb-mcp-server",
+      description: "Query and manage MongoDB databases and Atlas clusters",
+      category: "data",
+      requiredEnvKeys: [
+        "MDB_MCP_CONNECTION_STRING"
+      ],
+      repo: "https://github.com/mongodb-js/mongodb-mcp-server",
+      verified: !0
+    },
+    {
+      name: "redis",
+      displayName: "Redis",
+      iconKey: "redis",
+      pypiPackage: "redis-mcp-server",
+      runtime: "python",
+      description: "Query and manage Redis data structures",
+      category: "data",
+      requiredEnvKeys: [
+        "REDIS_URL"
+      ],
+      optionalEnvKeys: [
+        "REDIS_HOST",
+        "REDIS_PORT",
+        "REDIS_USERNAME",
+        "REDIS_PWD"
+      ],
+      repo: "https://github.com/redis/mcp-redis",
+      verified: !0
+    },
+    {
+      name: "clickhouse",
+      displayName: "ClickHouse",
+      iconKey: "clickhouse",
+      pypiPackage: "mcp-clickhouse",
+      runtime: "python",
+      description: "Run queries against ClickHouse (writes gated off by default)",
+      category: "data",
+      requiredEnvKeys: [
+        "CLICKHOUSE_HOST",
+        "CLICKHOUSE_USER",
+        "CLICKHOUSE_PASSWORD"
+      ],
+      optionalEnvKeys: [
+        "CLICKHOUSE_PORT",
+        "CLICKHOUSE_SECURE",
+        "CLICKHOUSE_DATABASE"
+      ],
+      repo: "https://github.com/ClickHouse/mcp-clickhouse",
+      verified: !0
+    },
+    {
+      name: "duckdb",
+      displayName: "DuckDB / MotherDuck",
+      iconKey: "duckdb",
+      pypiPackage: "mcp-server-motherduck",
+      runtime: "python",
+      args: [
+        "--db-path",
+        "{database-path}"
+      ],
+      description: "Query local DuckDB files or MotherDuck cloud databases (read-only by default)",
+      category: "data",
+      requiredEnvKeys: [],
+      optionalEnvKeys: [
+        "MOTHERDUCK_TOKEN"
+      ],
+      repo: "https://github.com/motherduckdb/mcp-server-motherduck",
+      runLocation: "host",
+      verified: !0,
+      prerequisite: "Database path can be a local .duckdb file or :memory:; MOTHERDUCK_TOKEN is only needed for MotherDuck cloud."
+    },
+    {
+      name: "dbhub",
+      displayName: "DBHub",
+      npmPackage: "@bytebase/dbhub",
+      description: "Universal database gateway: SQLite, PostgreSQL, MySQL, MariaDB, and SQL Server",
+      category: "data",
+      requiredEnvKeys: [
+        "DSN"
+      ],
+      repo: "https://github.com/bytebase/dbhub",
+      verified: !0,
+      prerequisite: "Set DSN to the database connection string (e.g. postgres://user:pass@host/db); requires Node 22.5+."
+    },
+    {
+      name: "chroma",
+      displayName: "Chroma",
+      pypiPackage: "chroma-mcp",
+      runtime: "python",
+      description: "Vector search and collections on Chroma (ephemeral mode is zero-config)",
+      category: "data",
+      requiredEnvKeys: [],
+      optionalEnvKeys: [
+        "CHROMA_CLIENT_TYPE",
+        "CHROMA_DATA_DIR",
+        "CHROMA_API_KEY",
+        "CHROMA_TENANT",
+        "CHROMA_DATABASE"
+      ],
+      repo: "https://github.com/chroma-core/chroma-mcp",
+      verified: !0
+    },
+    {
+      name: "qdrant",
+      displayName: "Qdrant",
+      iconKey: "qdrant",
+      pypiPackage: "mcp-server-qdrant",
+      runtime: "python",
+      description: "Semantic memory on Qdrant with built-in local embeddings (fastembed)",
+      category: "data",
+      requiredEnvKeys: [
+        "QDRANT_URL",
+        "COLLECTION_NAME"
+      ],
+      optionalEnvKeys: [
+        "QDRANT_API_KEY"
+      ],
+      repo: "https://github.com/qdrant/mcp-server-qdrant",
+      verified: !0
+    },
+    {
+      name: "pinecone",
+      displayName: "Pinecone",
+      npmPackage: "@pinecone-database/mcp",
+      description: "Search and manage Pinecone vector indexes",
+      category: "data",
+      requiredEnvKeys: [
+        "PINECONE_API_KEY"
+      ],
+      repo: "https://github.com/pinecone-io/pinecone-mcp",
+      verified: !0
+    },
+    {
+      name: "dbt",
+      displayName: "dbt",
+      pypiPackage: "dbt-mcp",
+      runtime: "python",
+      description: "dbt platform: semantic layer, discovery, and dbt CLI operations",
+      category: "data",
+      requiredEnvKeys: [
+        "DBT_HOST",
+        "DBT_TOKEN",
+        "DBT_PROD_ENV_ID"
+      ],
+      optionalEnvKeys: [
+        "DBT_ACCOUNT_ID",
+        "DBT_DEV_ENV_ID",
+        "DBT_USER_ID"
+      ],
+      repo: "https://github.com/dbt-labs/dbt-mcp",
+      verified: !0
+    },
+    {
+      name: "neon",
+      displayName: "Neon",
+      url: "https://mcp.neon.tech/mcp",
+      oauth: !0,
+      bearerTokenEnvVar: "NEON_API_KEY",
+      description: "Manage Neon serverless Postgres projects, branches, and queries",
+      category: "data",
+      requiredEnvKeys: [
+        "NEON_API_KEY"
+      ],
+      repo: "https://github.com/neondatabase/mcp-server-neon",
+      verified: !0
+    },
+    {
+      name: "postgres",
+      displayName: "PostgreSQL",
+      iconKey: "postgresql",
+      pypiPackage: "postgres-mcp",
+      runtime: "python",
+      description: "Postgres queries, schema intelligence, index tuning, and health checks",
+      category: "data",
+      requiredEnvKeys: [
+        "DATABASE_URI"
+      ],
+      repo: "https://github.com/crystaldba/postgres-mcp",
+      verified: !1
+    },
+    {
+      name: "mysql",
+      displayName: "MySQL",
+      iconKey: "mysql",
+      npmPackage: "@benborla29/mcp-server-mysql",
+      description: "Query MySQL databases (read-only by default, writes gated per-operation)",
+      category: "data",
+      requiredEnvKeys: [
+        "MYSQL_HOST",
+        "MYSQL_PORT",
+        "MYSQL_USER",
+        "MYSQL_PASS",
+        "MYSQL_DB"
+      ],
+      optionalEnvKeys: [
+        "ALLOW_INSERT_OPERATION",
+        "ALLOW_UPDATE_OPERATION",
+        "ALLOW_DELETE_OPERATION"
+      ],
+      repo: "https://github.com/benborla/mcp-server-mysql",
+      verified: !1
+    },
+    {
+      name: "sqlite",
+      displayName: "SQLite",
+      iconKey: "sqlite",
+      npmPackage: "mcp-sqlite",
+      args: [
+        "{database-path}"
+      ],
+      description: "Query and manage a local SQLite database file",
+      category: "data",
+      requiredEnvKeys: [],
+      repo: "https://github.com/jparkerweb/mcp-sqlite",
+      runLocation: "host",
+      verified: !1
+    },
+    {
+      name: "airtable",
+      displayName: "Airtable",
+      iconKey: "airtable",
+      npmPackage: "airtable-mcp-server",
+      description: "Read and write Airtable bases, tables, and records",
+      category: "data",
+      requiredEnvKeys: [
+        "AIRTABLE_API_KEY"
+      ],
+      repo: "https://github.com/domdomegg/airtable-mcp-server",
+      verified: !1,
+      prerequisite: "AIRTABLE_API_KEY is an Airtable personal access token from airtable.com/create/tokens (schema + records scopes)."
+    },
+    {
+      name: "google-sheets",
+      displayName: "Google Sheets",
+      iconKey: "google-sheets",
+      pypiPackage: "mcp-google-sheets",
+      runtime: "python",
+      description: "Read and write Google Sheets spreadsheets",
+      category: "data",
+      requiredEnvKeys: [
+        "SERVICE_ACCOUNT_PATH",
+        "DRIVE_FOLDER_ID"
+      ],
+      repo: "https://github.com/xing5/mcp-google-sheets",
+      runLocation: "host",
+      verified: !1,
+      prerequisite: "Headless service-account mode: needs a Google Cloud service-account JSON key (Sheets + Drive APIs enabled) and a Drive folder shared with the service account's email. SERVICE_ACCOUNT_PATH points at the key file."
+    },
+    {
+      name: "excel",
+      displayName: "Excel",
+      pypiPackage: "excel-mcp-server",
+      runtime: "python",
+      args: [
+        "stdio"
+      ],
+      description: "Create, read, and edit Excel workbooks without Excel installed",
+      category: "data",
+      requiredEnvKeys: [],
+      repo: "https://github.com/haris-musa/excel-mcp-server",
+      runLocation: "host",
+      verified: !1
+    },
+    {
+      name: "google-drive",
+      displayName: "Google Drive",
+      iconKey: "google-drive",
+      npmPackage: "@piotr-agier/google-drive-mcp",
+      description: "Read, search, and manage Google Drive, Docs, Sheets, and Slides",
+      category: "data",
+      requiredEnvKeys: [],
+      repo: "https://github.com/piotr-agier/google-drive-mcp",
+      runLocation: "host",
+      verified: !1,
+      auth: !0,
+      authArgs: [
+        "auth"
+      ],
+      credentialFiles: [
+        {
+          path: "~/.config/google-drive-mcp/gcp-oauth.keys.json",
+          required: !0
+        },
+        {
+          path: "~/.config/google-drive-mcp/tokens.json"
+        }
+      ],
+      prerequisite: "Needs a Google OAuth client JSON (Desktop app) from console.cloud.google.com with the Drive, Docs, Sheets, and Slides APIs enabled."
+    },
+    {
+      name: "resend",
+      displayName: "Resend",
+      npmPackage: "resend-mcp",
+      description: "Send emails, manage contacts, and broadcasts via the Resend platform",
+      category: "communication",
+      requiredEnvKeys: [
+        "RESEND_API_KEY"
+      ],
+      optionalEnvKeys: [
+        "SENDER_EMAIL_ADDRESS",
+        "REPLY_TO_EMAIL_ADDRESSES"
+      ],
+      repo: "https://github.com/resend/resend-mcp",
+      verified: !0
+    },
+    {
+      name: "slack",
+      displayName: "Slack",
+      npmPackage: "@zencoderai/slack-mcp-server",
+      description: "Interact with Slack workspaces via a bot token",
+      category: "communication",
+      requiredEnvKeys: [
+        "SLACK_BOT_TOKEN",
+        "SLACK_TEAM_ID"
+      ],
+      optionalEnvKeys: [
+        "SLACK_CHANNEL_IDS"
+      ],
+      repo: "https://github.com/zencoderai/slack-mcp-server",
+      verified: !1,
+      prerequisite: "Needs a Slack app (api.slack.com/apps) with bot scopes channels:history, channels:read, chat:write, reactions:write, users:read."
+    },
+    {
+      name: "email",
+      displayName: "Email (IMAP/SMTP)",
+      npmPackage: "@codefuturist/email-mcp",
+      description: "Search, read, and send email over IMAP and SMTP",
+      category: "communication",
+      requiredEnvKeys: [
+        "MCP_EMAIL_ADDRESS",
+        "MCP_EMAIL_PASSWORD",
+        "MCP_EMAIL_IMAP_HOST",
+        "MCP_EMAIL_SMTP_HOST"
+      ],
+      optionalEnvKeys: [
+        "MCP_EMAIL_IMAP_PORT",
+        "MCP_EMAIL_SMTP_PORT",
+        "MCP_EMAIL_IMAP_TLS",
+        "MCP_EMAIL_SMTP_TLS",
+        "MCP_EMAIL_SMTP_STARTTLS"
+      ],
+      repo: "https://github.com/codefuturist/email-mcp",
+      verified: !1,
+      prerequisite: "Use an app password for providers with 2FA (e.g. Gmail); requires Node 22+."
+    },
+    {
+      name: "telegram",
+      displayName: "Telegram",
+      iconKey: "telegram",
+      npmPackage: "@iqai/mcp-telegram",
+      description: "Interact with Telegram via bot API for messaging and channel management",
+      category: "communication",
+      requiredEnvKeys: [
+        "TELEGRAM_BOT_TOKEN"
+      ],
+      repo: "https://github.com/IQAIcom/mcp-telegram",
+      verified: !1
+    },
+    {
+      name: "discord",
+      displayName: "Discord",
+      iconKey: "discord",
+      npmPackage: "mcp-discord",
+      description: "Discord bot integration for messages, channels, forums, and webhooks",
+      category: "communication",
+      requiredEnvKeys: [
+        "DISCORD_TOKEN"
+      ],
+      repo: "https://github.com/barryyip0625/mcp-discord",
+      verified: !1
+    },
+    {
+      name: "gmail",
+      displayName: "Gmail",
+      iconKey: "gmail",
+      npmPackage: "@gongrzhe/server-gmail-autoauth-mcp",
+      description: "Search, read, label, and send Gmail",
+      category: "communication",
+      requiredEnvKeys: [],
+      repo: "https://github.com/GongRzhe/Gmail-MCP-Server",
+      runLocation: "host",
+      verified: !1,
+      auth: !0,
+      authArgs: [
+        "auth"
+      ],
+      credentialFiles: [
+        {
+          path: "~/.gmail-mcp/gcp-oauth.keys.json",
+          required: !0
+        },
+        {
+          path: "~/.gmail-mcp/credentials.json"
+        }
+      ],
+      prerequisite: "Needs a Google OAuth client JSON (Desktop app) from console.cloud.google.com with the Gmail API enabled. Upstream repo was archived in 2025 but this remains the most-used Gmail server."
+    },
+    {
+      name: "teams",
+      displayName: "Microsoft Teams",
+      npmPackage: "@floriscornel/teams-mcp",
+      description: "Read and send Microsoft Teams channel and chat messages as the signed-in user",
+      category: "communication",
+      requiredEnvKeys: [],
+      repo: "https://github.com/floriscornel/teams-mcp",
+      runLocation: "host",
+      verified: !1,
+      auth: !0,
+      authArgs: [
+        "authenticate"
+      ],
+      credentialFiles: [
+        {
+          path: "~/.teams-mcp-token-cache.json"
+        },
+        {
+          path: "~/.msgraph-mcp-auth.json"
+        }
+      ],
+      prerequisite: "Signs into Microsoft 365 with a device code on first auth \u2014 no Azure app registration needed (some tenants require admin consent for the shared client)."
+    },
+    {
+      name: "notion",
+      displayName: "Notion",
+      iconKey: "notion",
+      npmPackage: "@notionhq/notion-mcp-server",
+      description: "Search, read, and write Notion pages and databases",
+      category: "productivity",
+      requiredEnvKeys: [
+        "NOTION_TOKEN"
+      ],
+      repo: "https://github.com/makenotion/notion-mcp-server",
+      verified: !0,
+      prerequisite: "Needs an internal integration token (notion.so/profile/integrations); share the target pages with the integration."
+    },
+    {
+      name: "notion-remote",
+      displayName: "Notion (remote)",
+      iconKey: "notion",
+      url: "https://mcp.notion.com/mcp",
+      oauth: !0,
+      description: "Official Notion remote server \u2014 search, read, and write pages and databases via browser OAuth",
+      category: "productivity",
+      requiredEnvKeys: [],
+      repo: "https://developers.notion.com/docs/mcp",
+      verified: !0,
+      prerequisite: "Sign in to Notion in your browser on first connect \u2014 no integration token to paste."
+    },
+    {
+      name: "linear",
+      displayName: "Linear",
+      iconKey: "linear",
+      url: "https://mcp.linear.app/mcp",
+      oauth: !0,
+      bearerTokenEnvVar: "LINEAR_API_KEY",
+      description: "Official Linear remote server \u2014 issues, projects, and cycles",
+      category: "productivity",
+      requiredEnvKeys: [
+        "LINEAR_API_KEY"
+      ],
+      repo: "https://linear.app/docs/mcp",
+      verified: !0,
+      prerequisite: "Needs a Linear personal API key (Settings > Security & access > Personal API keys)."
+    },
+    {
+      name: "atlassian-cloud",
+      displayName: "Atlassian Cloud",
+      iconKey: "atlassian",
+      url: "https://mcp.atlassian.com/v1/mcp",
+      oauth: !0,
+      bearerTokenEnvVar: "ATLASSIAN_API_KEY",
+      description: "Official Atlassian remote server \u2014 Jira, Confluence, JSM, Bitbucket, and Compass",
+      category: "productivity",
+      requiredEnvKeys: [
+        "ATLASSIAN_API_KEY"
+      ],
+      repo: "https://github.com/atlassian/atlassian-mcp-server",
+      verified: !0,
+      prerequisite: "Needs a service-account API key, and an org admin must enable API-token access to the MCP server. Atlassian Cloud only."
+    },
+    {
+      name: "todoist",
+      displayName: "Todoist",
+      iconKey: "todoist",
+      npmPackage: "@doist/todoist-mcp",
+      description: "Manage Todoist tasks, projects, and labels",
+      category: "productivity",
+      requiredEnvKeys: [
+        "TODOIST_API_KEY"
+      ],
+      repo: "https://github.com/Doist/todoist-mcp",
+      verified: !0,
+      prerequisite: "API key from Todoist Settings > Integrations > Developer."
+    },
+    {
+      name: "todoist-remote",
+      displayName: "Todoist (remote)",
+      iconKey: "todoist",
+      url: "https://ai.todoist.net/mcp",
+      oauth: !0,
+      description: "Official Doist hosted server \u2014 manage Todoist tasks, projects, and labels via browser OAuth",
+      category: "productivity",
+      requiredEnvKeys: [],
+      repo: "https://github.com/Doist/todoist-mcp",
+      verified: !0,
+      prerequisite: "Sign in to Todoist in your browser on first connect \u2014 no API key to paste."
+    },
+    {
+      name: "clickup",
+      displayName: "ClickUp",
+      url: "https://mcp.clickup.com/mcp",
+      oauth: !0,
+      description: "Official ClickUp remote server \u2014 tasks, lists, docs, and workspaces via browser OAuth",
+      category: "productivity",
+      requiredEnvKeys: [],
+      repo: "https://developer.clickup.com/docs/connect-an-ai-assistant-to-clickups-mcp-server",
+      verified: !0,
+      prerequisite: "Sign in to ClickUp in your browser on first connect (OAuth only \u2014 API keys are not accepted). Public beta; rate-limited."
+    },
+    {
+      name: "readwise",
+      displayName: "Readwise",
+      url: "https://mcp2.readwise.io/mcp",
+      oauth: !0,
+      description: "Official Readwise remote server \u2014 Highlights and Reader documents via browser OAuth",
+      category: "productivity",
+      requiredEnvKeys: [],
+      repo: "https://github.com/readwiseio/readwise-mcp",
+      verified: !0,
+      prerequisite: "Sign in to Readwise in your browser on first connect \u2014 no access token to paste."
+    },
+    {
+      name: "monday",
+      displayName: "monday.com",
+      npmPackage: "@mondaydotcomorg/monday-api-mcp",
+      description: "Manage monday.com boards, items, and workflows",
+      category: "productivity",
+      requiredEnvKeys: [
+        "monday_token"
+      ],
+      repo: "https://github.com/mondaycom/monday-ai",
+      verified: !0
+    },
+    {
+      name: "cal-com",
+      displayName: "Cal.com",
+      iconKey: "cal-com",
+      npmPackage: "@calcom/cal-mcp",
+      description: "Manage Cal.com bookings and event types",
+      category: "productivity",
+      requiredEnvKeys: [
+        "CAL_API_KEY"
+      ],
+      repo: "https://github.com/calcom/cal-mcp",
+      verified: !0
+    },
+    {
+      name: "stripe",
+      displayName: "Stripe",
+      iconKey: "stripe",
+      npmPackage: "@stripe/mcp",
+      description: "Query and manage Stripe payments, customers, and subscriptions",
+      category: "productivity",
+      requiredEnvKeys: [
+        "STRIPE_SECRET_KEY"
+      ],
+      repo: "https://github.com/stripe/ai",
+      verified: !0,
+      prerequisite: "A restricted API key (dashboard.stripe.com/apikeys) scoped to just the resources the agent needs is strongly recommended."
+    },
+    {
+      name: "paypal",
+      displayName: "PayPal",
+      iconKey: "paypal",
+      npmPackage: "@paypal/mcp",
+      description: "Manage PayPal invoices, orders, and subscriptions",
+      category: "productivity",
+      requiredEnvKeys: [
+        "PAYPAL_ACCESS_TOKEN",
+        "PAYPAL_ENVIRONMENT"
+      ],
+      repo: "https://github.com/paypal/agent-toolkit",
+      verified: !0,
+      prerequisite: "Generate an access token from your PayPal developer client ID + secret; set PAYPAL_ENVIRONMENT to SANDBOX or PRODUCTION."
+    },
+    {
+      name: "hubspot",
+      displayName: "HubSpot",
+      iconKey: "hubspot",
+      npmPackage: "@hubspot/mcp-server",
+      description: "Query and manage HubSpot CRM objects and associations",
+      category: "productivity",
+      requiredEnvKeys: [
+        "PRIVATE_APP_ACCESS_TOKEN"
+      ],
+      repo: "https://developers.hubspot.com/mcp",
+      verified: !0,
+      prerequisite: "Needs a HubSpot private-app access token (Settings > Integrations > Private Apps). Beta."
+    },
+    {
+      name: "zapier",
+      displayName: "Zapier",
+      iconKey: "zapier",
+      url: "https://mcp.zapier.com/api/v1/connect",
+      bearerTokenEnvVar: "ZAPIER_MCP_TOKEN",
+      description: "Run actions across 8000+ apps through your Zapier MCP server",
+      category: "productivity",
+      requiredEnvKeys: [
+        "ZAPIER_MCP_TOKEN"
+      ],
+      repo: "https://zapier.com/mcp",
+      verified: !0,
+      prerequisite: "Create an MCP server and pick its tools at mcp.zapier.com first; use the token from its Connect tab."
+    },
+    {
+      name: "atlassian",
+      displayName: "Atlassian (self-host)",
+      iconKey: "atlassian",
+      pypiPackage: "mcp-atlassian",
+      runtime: "python",
+      description: "Jira and Confluence \u2014 Cloud, Server, and Data Center",
+      category: "productivity",
+      requiredEnvKeys: [],
+      optionalEnvKeys: [
+        "JIRA_URL",
+        "JIRA_USERNAME",
+        "JIRA_API_TOKEN",
+        "JIRA_PERSONAL_TOKEN",
+        "CONFLUENCE_URL",
+        "CONFLUENCE_USERNAME",
+        "CONFLUENCE_API_TOKEN"
+      ],
+      repo: "https://github.com/sooperset/mcp-atlassian",
+      verified: !1,
+      prerequisite: "Set the JIRA_* and/or CONFLUENCE_* trio for the products you use (Cloud: URL + username + API token; Server/DC: URL + personal access token)."
+    },
+    {
+      name: "trello",
+      displayName: "Trello",
+      iconKey: "trello",
+      npmPackage: "@delorenj/mcp-server-trello",
+      description: "Manage Trello boards, lists, and cards",
+      category: "productivity",
+      requiredEnvKeys: [
+        "TRELLO_API_KEY",
+        "TRELLO_TOKEN"
+      ],
+      optionalEnvKeys: [
+        "TRELLO_WORKSPACE_ID"
+      ],
+      repo: "https://github.com/delorenj/mcp-server-trello",
+      verified: !1,
+      prerequisite: "API key and token from trello.com/app-key."
+    },
+    {
+      name: "google-calendar",
+      displayName: "Google Calendar",
+      iconKey: "google-calendar",
+      npmPackage: "@cocal/google-calendar-mcp",
+      description: "Read, create, and manage Google Calendar events",
+      category: "productivity",
+      requiredEnvKeys: [
+        "GOOGLE_OAUTH_CREDENTIALS"
+      ],
+      repo: "https://github.com/nspady/google-calendar-mcp",
+      runLocation: "host",
+      verified: !1,
+      auth: !0,
+      authArgs: [
+        "auth"
+      ],
+      credentialFiles: [
+        {
+          path: "~/.config/google-calendar-mcp/gcp-oauth.keys.json",
+          required: !0
+        },
+        {
+          path: "~/.config/google-calendar-mcp/tokens.json"
+        }
+      ],
+      prerequisite: "Needs a Google OAuth client JSON (Desktop app) with the Calendar API enabled. GOOGLE_OAUTH_CREDENTIALS is the key file PATH (e.g. ~/.config/google-calendar-mcp/gcp-oauth.keys.json), not a token."
+    },
+    {
+      name: "google-docs",
+      displayName: "Google Docs",
+      iconKey: "google-docs",
+      npmPackage: "@a-bonus/google-docs-mcp",
+      description: "Read and edit Google Docs, Sheets, and Drive files",
+      category: "productivity",
+      requiredEnvKeys: [
+        "GOOGLE_CLIENT_ID",
+        "GOOGLE_CLIENT_SECRET"
+      ],
+      repo: "https://github.com/a-bonus/google-docs-mcp",
+      runLocation: "host",
+      verified: !1,
+      auth: !0,
+      authArgs: [
+        "auth"
+      ],
+      credentialFiles: [
+        {
+          path: "~/.config/google-docs-mcp/token.json"
+        }
+      ],
+      prerequisite: "Needs a Google OAuth client (ID + secret) from console.cloud.google.com with the Docs, Sheets, and Drive APIs enabled."
+    },
+    {
+      name: "workspace",
+      displayName: "Google Workspace",
+      pypiPackage: "workspace-mcp",
+      runtime: "python",
+      description: "All-in-one Google Workspace: Gmail, Drive, Calendar, Docs, Sheets, Slides, and more (120+ tools)",
+      category: "productivity",
+      requiredEnvKeys: [
+        "GOOGLE_OAUTH_CLIENT_ID",
+        "GOOGLE_OAUTH_CLIENT_SECRET"
+      ],
+      repo: "https://github.com/taylorwilsdon/google_workspace_mcp",
+      runLocation: "host",
+      verified: !1,
+      prerequisite: "Needs a Google OAuth client from console.cloud.google.com with each Workspace API enabled. Browser sign-in happens in-flow on first use (port 8000) \u2014 host run recommended."
+    },
+    {
+      name: "raindrop",
+      displayName: "Raindrop.io",
+      npmPackage: "@adeze/raindrop-mcp",
+      description: "Manage Raindrop.io bookmarks, collections, and tags",
+      category: "productivity",
+      requiredEnvKeys: [
+        "RAINDROP_ACCESS_TOKEN"
+      ],
+      repo: "https://github.com/adeze/raindrop-mcp",
+      verified: !1,
+      prerequisite: 'Test token from app.raindrop.io/settings/integrations (create an app, then "Test token").'
+    },
+    {
+      name: "grafana",
+      displayName: "Grafana",
+      iconKey: "grafana",
+      pypiPackage: "mcp-grafana",
+      runtime: "python",
+      description: "Query Grafana dashboards, datasources, alerts, and incidents",
+      category: "infra",
+      requiredEnvKeys: [
+        "GRAFANA_URL",
+        "GRAFANA_SERVICE_ACCOUNT_TOKEN"
+      ],
+      repo: "https://github.com/grafana/mcp-grafana",
+      verified: !0,
+      prerequisite: "Needs a reachable Grafana 9.0+ instance and a service-account token."
+    },
+    {
+      name: "pagerduty",
+      displayName: "PagerDuty",
+      iconKey: "pagerduty",
+      pypiPackage: "pagerduty-mcp",
+      runtime: "python",
+      description: "Query PagerDuty incidents, services, and on-call schedules (writes off by default)",
+      category: "infra",
+      requiredEnvKeys: [
+        "PAGERDUTY_USER_API_KEY"
+      ],
+      repo: "https://github.com/PagerDuty/pagerduty-mcp-server",
+      verified: !0
+    },
+    {
+      name: "netlify",
+      displayName: "Netlify",
+      iconKey: "netlify",
+      npmPackage: "@netlify/mcp",
+      description: "Create, build, deploy, and manage Netlify projects",
+      category: "infra",
+      requiredEnvKeys: [],
+      optionalEnvKeys: [
+        "NETLIFY_PERSONAL_ACCESS_TOKEN"
+      ],
+      repo: "https://github.com/netlify/netlify-mcp",
+      runLocation: "host",
+      verified: !0,
+      prerequisite: "Reuses Netlify CLI login state \u2014 run `netlify login` on host first (or set NETLIFY_PERSONAL_ACCESS_TOKEN). Requires Node 22+."
+    },
+    {
+      name: "cloudflare-bindings",
+      displayName: "Cloudflare Bindings",
+      iconKey: "cloudflare",
+      url: "https://bindings.mcp.cloudflare.com/mcp",
+      oauth: !0,
+      bearerTokenEnvVar: "CLOUDFLARE_API_TOKEN",
+      description: "Build with Cloudflare Workers: KV, R2, D1, and Durable Objects",
+      category: "infra",
+      requiredEnvKeys: [
+        "CLOUDFLARE_API_TOKEN"
+      ],
+      repo: "https://github.com/cloudflare/mcp-server-cloudflare",
+      verified: !0,
+      prerequisite: "Needs a Cloudflare API token scoped for Workers resources."
+    },
+    {
+      name: "cloudflare-observability",
+      displayName: "Cloudflare Observability",
+      iconKey: "cloudflare",
+      url: "https://observability.mcp.cloudflare.com/mcp",
+      oauth: !0,
+      bearerTokenEnvVar: "CLOUDFLARE_API_TOKEN",
+      description: "Debug Cloudflare Workers: logs, analytics, and errors",
+      category: "infra",
+      requiredEnvKeys: [
+        "CLOUDFLARE_API_TOKEN"
+      ],
+      repo: "https://github.com/cloudflare/mcp-server-cloudflare",
+      verified: !0,
+      prerequisite: "Needs a Cloudflare API token with Workers observability scopes."
+    },
+    {
+      name: "datadog",
+      displayName: "Datadog",
+      url: "https://mcp.datadoghq.com/v1/mcp",
+      headerEnv: [
+        {
+          header: "DD-API-KEY",
+          env: "DD_API_KEY"
+        },
+        {
+          header: "DD-APPLICATION-KEY",
+          env: "DD_APPLICATION_KEY"
+        }
+      ],
+      description: "Query Datadog monitors, dashboards, metrics, and incidents",
+      category: "infra",
+      requiredEnvKeys: [
+        "DD_API_KEY",
+        "DD_APPLICATION_KEY"
+      ],
+      repo: "https://docs.datadoghq.com/mcp_server/",
+      verified: !0,
+      prerequisite: "US1 endpoint \u2014 swap the host for your region (e.g. mcp.datadoghq.eu). Needs a Datadog API key and application key."
+    },
+    {
+      name: "prometheus",
+      displayName: "Prometheus",
+      iconKey: "prometheus",
+      pypiPackage: "prometheus-mcp-server",
+      runtime: "python",
+      description: "Run PromQL queries and explore Prometheus metrics",
+      category: "infra",
+      requiredEnvKeys: [
+        "PROMETHEUS_URL"
+      ],
+      repo: "https://github.com/pab1it0/prometheus-mcp-server",
+      verified: !1,
+      prerequisite: "Needs a reachable Prometheus server."
+    },
+    {
+      name: "kubernetes",
+      displayName: "Kubernetes",
+      iconKey: "kubernetes",
+      npmPackage: "kubernetes-mcp-server",
+      description: "Inspect and manage Kubernetes clusters via the native API (no kubectl needed)",
+      category: "infra",
+      requiredEnvKeys: [],
+      optionalEnvKeys: [
+        "KUBECONFIG"
+      ],
+      repo: "https://github.com/containers/kubernetes-mcp-server",
+      runLocation: "host",
+      verified: !1,
+      prerequisite: "Needs a kubeconfig on the machine it runs on \u2014 host run recommended."
+    },
+    {
+      name: "docker",
+      displayName: "Docker",
+      iconKey: "docker",
+      pypiPackage: "mcp-server-docker",
+      runtime: "python",
+      description: "Manage Docker containers, images, volumes, and networks",
+      category: "infra",
+      requiredEnvKeys: [],
+      optionalEnvKeys: [
+        "DOCKER_HOST"
+      ],
+      repo: "https://github.com/ckreiling/mcp-server-docker",
+      runLocation: "host",
+      verified: !1,
+      prerequisite: "Needs access to a Docker daemon \u2014 host run recommended (DOCKER_HOST supports ssh:// remotes)."
+    },
+    {
+      name: "elevenlabs",
+      displayName: "ElevenLabs",
+      iconKey: "elevenlabs",
+      pypiPackage: "elevenlabs-mcp",
+      runtime: "python",
+      description: "Text-to-speech, voice cloning, and audio generation via ElevenLabs",
+      category: "ai",
+      requiredEnvKeys: [
+        "ELEVENLABS_API_KEY"
+      ],
+      optionalEnvKeys: [
+        "ELEVENLABS_MCP_BASE_PATH",
+        "ELEVENLABS_MCP_OUTPUT_MODE"
+      ],
+      repo: "https://github.com/elevenlabs/elevenlabs-mcp",
+      verified: !0
+    },
+    {
+      name: "antv-chart",
+      displayName: "AntV Chart",
+      npmPackage: "@antv/mcp-server-chart",
+      description: "Generate 25+ chart types as images via AntV",
+      category: "ai",
+      requiredEnvKeys: [],
+      repo: "https://github.com/antvis/mcp-server-chart",
+      verified: !0
+    },
+    {
+      name: "browserbase",
+      displayName: "Browserbase",
+      npmPackage: "@browserbasehq/mcp",
+      description: "Cloud browser automation with Stagehand \u2014 act, extract, and observe on any site",
+      category: "ai",
+      requiredEnvKeys: [
+        "BROWSERBASE_API_KEY",
+        "BROWSERBASE_PROJECT_ID",
+        "GEMINI_API_KEY"
+      ],
+      repo: "https://github.com/browserbase/mcp-server-browserbase",
+      verified: !0,
+      prerequisite: "Needs a Browserbase API key + project ID, plus a Gemini API key for the default Stagehand model."
+    },
+    {
+      name: "huggingface",
+      displayName: "Hugging Face",
+      iconKey: "huggingface",
+      url: "https://huggingface.co/mcp",
+      oauth: !0,
+      bearerTokenEnvVar: "HF_TOKEN",
+      description: "Search Hugging Face models, datasets, papers, and Spaces",
+      category: "ai",
+      requiredEnvKeys: [
+        "HF_TOKEN"
+      ],
+      repo: "https://github.com/huggingface/hf-mcp-server",
+      verified: !0,
+      prerequisite: "Needs a Hugging Face access token (huggingface.co/settings/tokens, Read scope)."
+    },
+    {
+      name: "mermaid",
+      displayName: "Mermaid",
+      iconKey: "mermaid",
+      npmPackage: "mcp-mermaid",
+      description: "Generate and render Mermaid diagrams",
+      category: "ai",
+      requiredEnvKeys: [],
+      repo: "https://github.com/hustcc/mcp-mermaid",
+      verified: !1
+    },
+    {
+      name: "blender",
+      displayName: "Blender",
+      iconKey: "blender",
+      pypiPackage: "blender-mcp",
+      runtime: "python",
+      description: "Control Blender for 3D modeling and scene creation",
+      category: "ai",
+      requiredEnvKeys: [],
+      repo: "https://github.com/ahujasid/blender-mcp",
+      runLocation: "host",
+      verified: !1,
+      prerequisite: 'Install the Blender MCP addon and click "Start MCP Server" inside Blender first; connects to localhost:9876 \u2014 host run required.'
+    }
+  ]
+};
+
+// src/shared/schemas/mcp-registry.schema.ts
+var McpRegistryEntrySchema = external_exports.object({
+  name: external_exports.string().min(1),
+  displayName: external_exports.string().min(1),
+  npmPackage: external_exports.string().min(1).optional(),
+  pypiPackage: external_exports.string().min(1).optional(),
+  runtime: external_exports.enum(["node", "python"]).optional(),
+  args: external_exports.array(external_exports.string()).optional(),
+  url: external_exports.string().min(1).optional(),
+  headerEnv: external_exports.array(external_exports.object({ header: external_exports.string().min(1), env: external_exports.string().min(1) })).optional(),
+  bearerTokenEnvVar: external_exports.string().min(1).optional(),
+  // OAuth fields are only meaningful on `url` (remote HTTP) entries — the
+  // schema does not enforce that (keeps the parser simple), but a non-url
+  // entry carrying them is ignored by registrationFromRegistryEntry.
+  oauth: external_exports.boolean().optional(),
+  oauthClientId: external_exports.string().optional(),
+  oauthScopes: external_exports.array(external_exports.string()).optional(),
+  description: external_exports.string().min(1),
+  category: external_exports.enum(["tools", "data", "dev", "communication", "web", "search", "productivity", "infra", "ai"]),
+  requiredEnvKeys: external_exports.array(external_exports.string()),
+  optionalEnvKeys: external_exports.array(external_exports.string()).optional(),
+  repo: external_exports.string().optional(),
+  verified: external_exports.boolean(),
+  iconKey: external_exports.string().optional(),
+  auth: external_exports.boolean().optional(),
+  authArgs: external_exports.array(external_exports.string()).optional(),
+  credentialFiles: external_exports.array(external_exports.object({
+    path: external_exports.string().min(1),
+    required: external_exports.boolean().optional(),
+    writeBack: external_exports.boolean().optional()
+  })).optional(),
+  prerequisite: external_exports.string().optional(),
+  deprecated: external_exports.string().optional(),
+  advisory: external_exports.string().optional(),
+  // Absent = containerized (the default for every install). 'host' marks an
+  // entry that cannot work in the container — see McpRegistryEntry.runLocation
+  // for the criteria. Only meaningful on stdio (non-url) entries.
+  runLocation: external_exports.enum(["host", "shared"]).optional()
+}).refine(
+  (e) => !!(e.npmPackage || e.pypiPackage || e.url),
+  { message: "entry needs at least one of npmPackage / pypiPackage / url" }
+);
+function parseMcpRegistryDocument(json) {
+  if (typeof json != "object" || json === null || Array.isArray(json)) return null;
+  let doc = json;
+  if (typeof doc.schemaVersion != "number" || doc.schemaVersion > 1 || !Array.isArray(doc.entries)) return null;
+  let entries = [], dropped = 0;
+  for (let raw of doc.entries) {
+    let result = McpRegistryEntrySchema.safeParse(raw);
+    result.success ? entries.push(result.data) : dropped++;
+  }
+  return {
+    entries,
+    updatedAt: typeof doc.updatedAt == "string" ? doc.updatedAt : void 0,
+    dropped
+  };
+}
+
+// src/shared/constants/mcp-registry.ts
+var parsedBundledRegistry = parseMcpRegistryDocument(mcp_registry_default);
+if (!parsedBundledRegistry || parsedBundledRegistry.dropped > 0)
+  throw new Error("Bundled mcp-registry.json failed schema validation \u2014 fix /mcp-registry.json");
+var MCP_REGISTRY = parsedBundledRegistry.entries, BUNDLED_REGISTRY_UPDATED_AT = parsedBundledRegistry.updatedAt, REGISTRY_ARG_PLACEHOLDER_RE = /\{[a-z0-9-]+\}/;
+function hasUnresolvedPlaceholderArgs(args) {
+  return (args ?? []).some((arg) => REGISTRY_ARG_PLACEHOLDER_RE.test(arg));
+}
+var HOST_ONLY_REGISTRY_ENTRIES = /* @__PURE__ */ new Set([
+  // Host binary, daemon, or loopback listener
+  "pandoc",
+  "docker",
+  "kubernetes",
+  "blender",
+  "chrome-devtools",
+  // Host CLI login state / in-flow browser sign-in the preflight can't drive
+  "netlify",
+  "workspace",
+  // Host filesystem paths (the container has no bind mount of the host FS)
+  "filesystem",
+  "sqlite",
+  "duckdb",
+  "git",
+  "markitdown",
+  "excel",
+  "semgrep",
+  "google-sheets",
+  // Settings-side auth preflight + credential-file storage (host-only today)
+  "gmail",
+  "google-drive",
+  "google-calendar",
+  "google-docs",
+  "teams"
+]);
+function registryEntryRunLocation(entry) {
+  if (!entry.url)
+    return entry.runLocation ? entry.runLocation : HOST_ONLY_REGISTRY_ENTRIES.has(entry.name) ? "host" : void 0;
+}
+var HOST_ONLY_REGISTRY_ENTRY_NAMES = [...HOST_ONLY_REGISTRY_ENTRIES];
+function registrationFromRegistryEntry(entry, id) {
+  if (entry.url) {
+    let envKeys = [.../* @__PURE__ */ new Set([
+      ...entry.requiredEnvKeys,
+      ...entry.optionalEnvKeys ?? [],
+      ...entry.bearerTokenEnvVar ? [entry.bearerTokenEnvVar] : [],
+      ...(entry.headerEnv ?? []).map(({ env }) => env)
+    ])];
+    return {
+      id,
+      name: entry.name,
+      type: "http",
+      url: entry.url,
+      description: entry.description,
+      repo: entry.repo,
+      env: envKeys.map((k) => ({ key: k, value: "" })),
+      ...entry.oauth ? { oauth: !0 } : {},
+      // Dual-mode: even when oauth is the default, seed the bearer/header env so
+      // the paste-token fallback stays available (CI/daemon users).
+      ...entry.bearerTokenEnvVar ? { bearerTokenEnvVar: entry.bearerTokenEnvVar } : {},
+      // Registration headerEnv rows are { key: headerName, value: envVarName }.
+      ...entry.headerEnv?.length ? { headerEnv: entry.headerEnv.map(({ header, env }) => ({ key: header, value: env })) } : {}
+    };
+  }
+  let isPython = entry.runtime === "python", runLocation = registryEntryRunLocation(entry);
+  return {
+    id,
+    name: entry.name,
+    type: isPython ? "uvx" : "npm",
+    npmPackage: isPython ? void 0 : entry.npmPackage,
+    pypiPackage: isPython ? entry.pypiPackage : void 0,
+    description: entry.description,
+    managed: !0,
+    env: [...entry.requiredEnvKeys, ...entry.optionalEnvKeys ?? []].map((k) => ({ key: k, value: "" })),
+    repo: entry.repo,
+    // Only entries that ask for a run location carry one; absent = container.
+    ...runLocation ? { runLocation } : {},
+    // Placeholders are copied verbatim — the modal resolves them before install.
+    ...entry.args?.length ? { args: [...entry.args] } : {},
+    ...entry.auth ? { auth: !0 } : {},
+    ...entry.authArgs ? { authArgs: entry.authArgs } : {},
+    ...entry.credentialFiles ? { credentialFiles: entry.credentialFiles.map((f) => ({ ...f })) } : {}
+  };
+}
+function findEntryIn(entries, lookup) {
+  if (lookup.npmPackage !== void 0) return entries.find((e) => e.npmPackage === lookup.npmPackage);
+  if (lookup.pypiPackage !== void 0) return entries.find((e) => e.pypiPackage === lookup.pypiPackage);
+  if (lookup.url !== void 0) return entries.find((e) => e.url === lookup.url);
+  if (lookup.name !== void 0) return entries.find((e) => e.name === lookup.name);
+}
+function findRegistryEntry(npmPackage) {
+  return MCP_REGISTRY.find((e) => e.npmPackage === npmPackage);
+}
+function findRegistryEntryByPypiPackage(pypiPackage) {
+  return MCP_REGISTRY.find((e) => e.pypiPackage === pypiPackage);
+}
+function findRegistryEntryByName(name) {
+  return MCP_REGISTRY.find((e) => e.name === name);
+}
+function findRegistryEntryByUrl(url) {
+  return MCP_REGISTRY.find((e) => e.url === url);
+}
+
+// src/main/tui/setup/mcp.ts
+var { MCP_REGISTRY: MCP_REGISTRY2, registrationFromRegistryEntry: registrationFromRegistryEntry2, hasUnresolvedPlaceholderArgs: hasUnresolvedPlaceholderArgs2, REGISTRY_ARG_PLACEHOLDER_RE: REGISTRY_ARG_PLACEHOLDER_RE2 } = cjs(mcp_registry_exports), { buildMcpServerConfigFromRegistration, mcpCredentialNamespace } = cjs(mcp_config_exports), MCP_OVERLAY = "mcp";
+function mcpSourceRows() {
+  let custom = [
+    { kind: "npm", label: "npm package", detail: "Any MCP server published to npm (e.g. @modelcontextprotocol/server-everything)" },
+    { kind: "python", label: "Python package (uvx)", detail: "Any MCP server on PyPI, run with uvx (e.g. mcp-server-fetch)" },
+    { kind: "http", label: "Remote server (URL)", detail: "A Streamable HTTP MCP endpoint; token from an env var" }
+  ], catalog = MCP_REGISTRY2.filter((e) => !e.deprecated).map((entry) => ({ kind: "catalog", entry, label: entry.displayName, detail: entry.description }));
+  return [...custom, ...catalog];
+}
+function parseAddTarget(arg) {
+  let raw = (arg ?? "").trim();
+  if (!raw) return {};
+  let rows = mcpSourceRows();
+  if (/^https?:\/\//i.test(raw)) {
+    let known = rows.find((r) => r.entry?.url === raw);
+    return known ? { row: known } : { row: rows.find((r) => r.kind === "http"), value: raw };
+  }
+  let prefixed = raw.match(/^(npm|python|uvx|pip):(.+)$/i);
+  if (prefixed) {
+    let kind = prefixed[1].toLowerCase() === "npm" ? "npm" : "python";
+    return { row: rows.find((r) => r.kind === kind), value: prefixed[2].trim() };
+  }
+  let wanted = raw.toLowerCase(), entry = rows.find((r) => r.entry && (r.entry.name === wanted || r.entry.npmPackage === raw || r.entry.pypiPackage === raw || r.entry.displayName.toLowerCase() === wanted));
+  return entry ? { row: entry } : { row: rows.find((r) => r.kind === "npm"), value: raw };
+}
+function sanitizeServerName(value) {
+  return value.toLowerCase().replace(/^@[^/]+\//, "").replace(/^mcp-server-|-mcp-server$|^server-|-mcp$|^mcp-/g, "").replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+}
+function defaultServerName(row, value = "") {
+  if (row.entry) return row.entry.name;
+  if (row.kind === "http")
+    try {
+      return sanitizeServerName(new URL(value).hostname.split(".").slice(-2, -1)[0] ?? "");
+    } catch {
+      return "";
+    }
+  return sanitizeServerName(value.split("/").pop() ?? value);
+}
+function envKeysOf(row) {
+  let e = row.entry;
+  if (!e) return row.kind === "http" ? [{ key: "MCP_TOKEN", required: !1 }] : [];
+  let keys = [
+    ...e.requiredEnvKeys.map((key) => ({ key, required: !0 })),
+    ...(e.optionalEnvKeys ?? []).map((key) => ({ key, required: !1 })),
+    ...e.bearerTokenEnvVar ? [{ key: e.bearerTokenEnvVar, required: !!e.url && !e.oauth }] : [],
+    ...(e.headerEnv ?? []).map((h) => ({ key: h.env, required: !0 }))
+  ];
+  return keys.filter((k, i) => keys.findIndex((x) => x.key === k.key) === i);
+}
+function studioOnlyReason(row) {
+  let e = row.entry;
+  return e ? e.url && e.oauth && !e.bearerTokenEnvVar && !e.headerEnv?.length ? `${e.displayName} signs in with OAuth in the browser, which only ADF Studio runs today. Add it in Studio (Settings \u2192 MCP \u2192 ${e.displayName}, Connect), then it shows up here.` : e.auth || (e.credentialFiles?.length ?? 0) > 0 ? `${e.displayName} needs a one-time sign-in step (it writes a credential file), which ADF Studio runs. Add it in Studio (Settings \u2192 MCP), then it shows up here.` : null : null;
+}
+function validateMcpForm(row, form, taken) {
+  let errors = {};
+  if (form.name ? form.name !== sanitizeServerName(form.name) || !/^[a-z0-9][a-z0-9_-]*$/.test(form.name) ? errors.name = "Lowercase letters, digits, - and _ only." : taken.includes(form.name) && (errors.name = `This agent already has a server named ${form.name}.`) : errors.name = "Give it a name (letters, digits, - and _).", !row.entry) {
+    let source = form.source.trim();
+    if (!source) errors.source = row.kind === "http" ? "The server URL." : "The package name.";
+    else if (row.kind === "http")
+      try {
+        /^https?:$/.test(new URL(source).protocol) || (errors.source = "Use an http(s) URL.");
+      } catch {
+        errors.source = "Not a URL.";
+      }
+    else /\s/.test(source) && (errors.source = "One package name, no spaces.");
+  }
+  hasUnresolvedPlaceholderArgs2(splitArgs(form.args)) && (errors.args = "Fill in the {placeholders}.");
+  for (let { key, required } of envKeysOf(row))
+    required && !(form.env[key] ?? "").trim() && (errors[`env:${key}`] = `${key} is required.`);
+  return errors;
+}
+function splitArgs(text) {
+  let out = [], pattern = /"((?:[^"\\]|\\.)*)"|'([^']*)'|(\S+)/g, m;
+  for (; m = pattern.exec(text); ) out.push(m[1] !== void 0 ? m[1].replace(/\\(.)/g, "$1") : m[2] ?? m[3]);
+  return out;
+}
+function joinArgs(args) {
+  return (args ?? []).map((a) => /\s/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a).join(" ");
+}
+function registrationFor(row, form) {
+  let envKeys = envKeysOf(row).map((k) => k.key), base = row.entry ? registrationFromRegistryEntry2(row.entry, `tui:${form.name}`) : row.kind === "http" ? { id: `tui:${form.name}`, name: form.name, type: "http", url: form.source.trim(), ...form.env.MCP_TOKEN?.trim() ? { bearerTokenEnvVar: "MCP_TOKEN" } : {} } : row.kind === "python" ? { id: `tui:${form.name}`, name: form.name, type: "uvx", pypiPackage: form.source.trim(), managed: !0 } : { id: `tui:${form.name}`, name: form.name, type: "npm", npmPackage: form.source.trim(), managed: !0 }, isHttp = base.type === "http", args = splitArgs(form.args), keysWithValues = envKeys.filter((k) => (form.env[k] ?? "").trim());
+  return {
+    ...base,
+    name: form.name,
+    credentialStorage: "agent",
+    // Keys only: values go to the agent's identity store.
+    env: (row.entry ? envKeys : keysWithValues).map((key) => ({ key, value: "" })),
+    // Remote catalog entries that also take a token: the token path (OAuth runs in Studio only).
+    ...isHttp && base.oauth && base.bearerTokenEnvVar ? { oauth: !1 } : {},
+    ...isHttp ? {} : { args: args.length ? args : void 0 },
+    // Container unless the user picked the host (a catalog entry's host default is only a preselection).
+    runLocation: !isHttp && form.runOn === "host" ? "host" : void 0
+  };
+}
+function serverConfigFor(row, form) {
+  return buildMcpServerConfigFromRegistration(registrationFor(row, form));
+}
+function credentialNamespace(server) {
+  return mcpCredentialNamespace(server);
+}
+function packageToInstall(server) {
+  return server.transport === "http" ? null : server.npm_package ? { kind: "npm", name: server.npm_package } : server.pypi_package ? { kind: "python", name: server.pypi_package } : null;
+}
+function serverEnvKeys(server) {
+  return [.../* @__PURE__ */ new Set([
+    ...server.env_keys ?? [],
+    ...(server.env_schema ?? []).map((e) => e.key),
+    ...server.bearer_token_env_var ? [server.bearer_token_env_var] : [],
+    ...(server.header_env ?? []).map((h) => h.env)
+  ])];
+}
+function runsOnText(server, location) {
+  return location || (server ? server.transport === "http" ? "remote" : server.run_location === "host" ? "host" : server.run_location === "shared" ? "shared container" : "container" : "");
+}
+function serverToolDecls(tools, server) {
+  let prefix = `mcp_${server}_`;
+  return (tools ?? []).filter((t) => t.name.startsWith(prefix)).map((t) => ({ name: t.name, tool: t.name.slice(prefix.length), enabled: t.enabled !== !1 }));
+}
+
+// src/main/tui/setup/open.ts
+function channelsIdentityReady(store) {
+  let identity = store.getState().identity;
+  return !identity || identity.status === "ready";
+}
+function secretStoreReady(store) {
+  let identity = store.getState().identity;
+  return identity ? identity.storage === "keychain" ? identity.status !== "locked" : identity.status === "ready" : !0;
+}
+function openChannels(store, props = {}) {
+  let state = store.getState(), agentId = props.agentId ?? state.selectedAgentId;
+  if (!agentId || !state.agents[agentId]) {
+    store.actions.toast("Select an agent first (sidebar or /agent), or create one with /new", "warn");
+    return;
+  }
+  let next = { agentId, ...props.channel ? { channel: props.channel } : {} };
+  if (props.channel && !channelsIdentityReady(store)) {
+    identityFirst(store, CHANNELS_OVERLAY, next, "Channel credentials are sealed under your owner identity: set it up first, then the channel setup follows.");
+    return;
+  }
+  store.actions.pushOverlay({ kind: CHANNELS_OVERLAY, props: { ...next } });
+}
+function openProviderAdd(store, props = {}) {
+  if (!secretStoreReady(store)) {
+    identityFirst(store, PROVIDER_OVERLAY, { ...props }, "API keys go into the daemon\u2019s secret store, which is protected by your owner identity here: set it up or unlock it first.");
+    return;
+  }
+  store.actions.pushOverlay({ kind: PROVIDER_OVERLAY, props: { ...props } });
+}
+function openMcp(store, props = {}) {
+  let state = store.getState(), agentId = props.agentId ?? state.selectedAgentId;
+  if (!agentId || !state.agents[agentId]) {
+    store.actions.toast("Select an agent first (sidebar or /agent), or create one with /new", "warn");
+    return;
+  }
+  store.actions.pushOverlay({ kind: MCP_OVERLAY, props: { ...props, agentId } });
+}
+function openWelcome(store) {
+  store.actions.pushOverlay({ id: WELCOME_OVERLAY, kind: WELCOME_OVERLAY });
+}
+function identityFirst(store, then, thenProps, reason) {
+  openIdentity(store, { mode: "status", then, thenProps, reason });
+}
+
+export {
+  elementRect,
+  rectContains,
+  createKeyRouter,
+  KeyRouterProvider,
+  useKeyRouter,
+  useKeys,
+  WHEEL_STEP,
+  useWheel,
+  useClick,
+  keyLabel,
+  IDENTITY_OVERLAY,
+  NEW_AGENT_OVERLAY,
+  IDENTITY_BANNER_KEY,
+  SAVED_WORD,
+  shortDid,
+  normalizePhrase,
+  phraseWords,
+  isLoopbackUrl,
+  LOOPBACK_ONLY_TEXT,
+  IDENTITY_EXPLAINER,
+  identityErrorText,
+  identityBadge,
+  onboardingLines,
+  onboardingChoices,
+  passphraseProblem,
+  KeyHints,
+  openIdentity,
+  openNewAgent,
+  bannerKeyOf,
+  needsAttention,
+  identityKey,
+  IdentityOnboarding,
+  IdentityBanner,
+  CHANNELS_OVERLAY,
+  CHANNEL_ORDER,
+  channelEntries,
+  findChannel,
+  credentialFields,
+  DEFAULT_ADAPTER_CONFIG,
+  validateCredentials,
+  adapterLiveState,
+  configuredChannels,
+  PROVIDER_OVERLAY,
+  providerRows,
+  findProviderRow,
+  keyOptional,
+  needsBaseUrl,
+  validateProvider,
+  providerInput,
+  keyStorageText,
+  MCP_OVERLAY,
+  mcpSourceRows,
+  parseAddTarget,
+  defaultServerName,
+  envKeysOf,
+  studioOnlyReason,
+  validateMcpForm,
+  joinArgs,
+  serverConfigFor,
+  credentialNamespace,
+  packageToInstall,
+  serverEnvKeys,
+  runsOnText,
+  serverToolDecls,
+  channelsIdentityReady,
+  secretStoreReady,
+  openChannels,
+  openProviderAdd,
+  openMcp,
+  openWelcome,
+  identityFirst
+};