@hasna/mcps 0.0.12 → 0.0.14

package/bin/index.js

@@ -11944,6 +11944,85 @@ var init_config2 = __esm(() => {
   DB_PATH = process.env.HASNA_MCPS_DB_PATH ?? process.env.MCPS_DB_PATH ?? join5(MCPS_DIR, "registry.db");
 });
 
+// src/lib/provider-profile-seeds.ts
+var DEFAULT_PROVIDER_PROFILE_SEEDS;
+var init_provider_profile_seeds = __esm(() => {
+  DEFAULT_PROVIDER_PROFILE_SEEDS = [
+    {
+      id: "notion",
+      displayName: "Notion",
+      description: "Connect a Notion workspace so agents can search, read, create, and update workspace content.",
+      endpoint: "https://mcp.notion.com/mcp",
+      transport: "streamable-http",
+      fallbackEndpoints: [
+        {
+          transport: "sse",
+          url: "https://mcp.notion.com/sse",
+          notes: "Fallback for clients that do not support Streamable HTTP."
+        }
+      ],
+      authType: "oauth2",
+      authMetadata: {
+        oauthVersion: "2.0",
+        pkce: true,
+        dynamicClientRegistration: true,
+        bearerToken: "none",
+        notes: "Remote Notion MCP uses OAuth with PKCE. Bearer-token authentication is only appropriate for self-hosted/local fallback deployments."
+      },
+      tokenMode: "workspace",
+      installFallback: {
+        command: "npx",
+        args: ["-y", "mcp-remote", "https://mcp.notion.com/sse", "--transport", "sse-only"],
+        packageName: "mcp-remote",
+        url: "https://mcp.notion.com/sse"
+      },
+      docsUrl: "https://developers.notion.com/guides/mcp/build-mcp-client",
+      safety: {
+        requiresApproval: true,
+        dataClasses: ["workspace_content", "pages", "databases", "comments"],
+        notes: "Connected agents operate with the authorizing user's workspace access. Human confirmation is recommended for write-capable workflows."
+      },
+      provenance: {
+        source: "curated",
+        sourceUrl: "https://developers.notion.com/guides/mcp/build-mcp-client",
+        verifiedAt: "2026-05-10"
+      }
+    },
+    {
+      id: "linear",
+      displayName: "Linear",
+      description: "Connect Linear so agents can find, create, and update issues, projects, comments, and related workspace objects.",
+      endpoint: "https://mcp.linear.app/mcp",
+      transport: "streamable-http",
+      authType: "oauth2",
+      authMetadata: {
+        oauthVersion: "2.1",
+        dynamicClientRegistration: true,
+        bearerToken: "optional",
+        notes: "Linear supports interactive OAuth 2.1 with dynamic client registration and optional Authorization: Bearer tokens for OAuth tokens or API keys."
+      },
+      tokenMode: "workspace",
+      installFallback: {
+        command: "npx",
+        args: ["-y", "mcp-remote", "https://mcp.linear.app/mcp"],
+        packageName: "mcp-remote",
+        url: "https://mcp.linear.app/mcp"
+      },
+      docsUrl: "https://linear.app/docs/mcp",
+      safety: {
+        requiresApproval: true,
+        dataClasses: ["issues", "projects", "comments", "teams", "users"],
+        notes: "Linear tools can create and update workspace objects, so write actions should be policy-gated by the platform."
+      },
+      provenance: {
+        source: "curated",
+        sourceUrl: "https://linear.app/docs/mcp",
+        verifiedAt: "2026-05-10"
+      }
+    }
+  ];
+});
+
 // src/lib/db.ts
 import { mkdirSync as mkdirSync5 } from "fs";
 function getDb() {
@@ -12029,6 +12108,50 @@ function getDb() {
         ('github-mcp-topic', 'GitHub MCP Topic', 'github-topic', 'https://api.github.com/search/repositories', 'GitHub repositories tagged with mcp-server topic')
     `);
   }
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS provider_profiles (
+      id TEXT PRIMARY KEY,
+      display_name TEXT NOT NULL,
+      description TEXT,
+      endpoint TEXT,
+      transport TEXT NOT NULL,
+      fallback_endpoints TEXT NOT NULL DEFAULT '[]',
+      auth_type TEXT NOT NULL,
+      auth_metadata TEXT NOT NULL DEFAULT '{}',
+      scopes TEXT NOT NULL DEFAULT '[]',
+      token_mode TEXT NOT NULL DEFAULT 'none',
+      install_fallback TEXT NOT NULL DEFAULT '{}',
+      docs_url TEXT,
+      safety TEXT NOT NULL DEFAULT '{}',
+      provenance TEXT NOT NULL DEFAULT '{"source":"manual"}',
+      enabled INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  try {
+    db.exec("ALTER TABLE provider_profiles ADD COLUMN fallback_endpoints TEXT NOT NULL DEFAULT '[]'");
+  } catch {}
+  try {
+    db.exec("ALTER TABLE provider_profiles ADD COLUMN auth_metadata TEXT NOT NULL DEFAULT '{}'");
+  } catch {}
+  db.exec("CREATE INDEX IF NOT EXISTS idx_provider_profiles_enabled ON provider_profiles(enabled)");
+  const providerProfileCount = db.query("SELECT COUNT(*) as c FROM provider_profiles").get().c;
+  if (providerProfileCount === 0) {
+    const insertProviderProfile = db.prepare(`
+      INSERT OR IGNORE INTO provider_profiles (
+        id, display_name, description, endpoint, transport, fallback_endpoints,
+        auth_type, auth_metadata, scopes, token_mode, install_fallback,
+        docs_url, safety, provenance, enabled
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const run = db.transaction(() => {
+      for (const profile of DEFAULT_PROVIDER_PROFILE_SEEDS) {
+        insertProviderProfile.run(profile.id, profile.displayName, profile.description ?? null, profile.endpoint ?? null, profile.transport, JSON.stringify(profile.fallbackEndpoints ?? []), profile.authType, JSON.stringify(profile.authMetadata ?? {}), JSON.stringify(profile.scopes ?? []), profile.tokenMode ?? "none", JSON.stringify(profile.installFallback ?? null), profile.docsUrl ?? null, JSON.stringify(profile.safety ?? {}), JSON.stringify(profile.provenance), profile.enabled === false ? 0 : 1);
+      }
+    });
+    run();
+  }
   db.exec(`
     CREATE TABLE IF NOT EXISTS feedback (
       id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
@@ -12059,6 +12182,7 @@ var db = null, _adapter = null;
 var init_db = __esm(() => {
   init_dist();
   init_config2();
+  init_provider_profile_seeds();
 });
 
 // node_modules/ajv/dist/compile/codegen/code.js
@@ -19288,15 +19412,23 @@ var init_sources = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@hasna/mcps",
-    version: "0.0.12",
+    version: "0.0.14",
     description: "Meta-MCP registry & CLI \u2014 discover, manage, and proxy MCP servers",
     type: "module",
+    repository: {
+      type: "git",
+      url: "git+https://github.com/hasna/mcps.git"
+    },
     main: "dist/index.js",
     types: "dist/index.d.ts",
     exports: {
       ".": {
         import: "./dist/index.js",
         types: "./dist/index.d.ts"
+      },
+      "./mcp": {
+        import: "./dist/mcp/index.js",
+        types: "./dist/mcp/index.d.ts"
       }
     },
     bin: {
@@ -19311,7 +19443,7 @@ var require_package = __commonJS((exports, module) => {
       "README.md"
     ],
     scripts: {
-      build: "bun run build:dashboard && bun build ./src/cli/index.tsx --outdir ./bin --target bun --external ink --external react --external chalk && bun build ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun run scripts/fix-shebangs.ts && bun build ./src/index.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist",
+      build: "bun run build:dashboard && bun build ./src/cli/index.tsx --outdir ./bin --target bun --external ink --external react --external chalk && bun build ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun run scripts/fix-shebangs.ts && bun build ./src/index.ts --outdir ./dist --target bun && bun build ./src/mcp/index.ts --outdir ./dist/mcp --target bun && tsc --emitDeclarationOnly --declaration --outDir dist",
       "build:dashboard": "cd dashboard && bun install && bun run build",
       dev: "bun run src/cli/index.tsx",
       "dev:mcp": "bun run src/mcp/index.ts",
@@ -36759,9 +36891,169 @@ async function runFleetInstall(options = {}, dependencies = {}) {
   }));
 }
 
+// src/lib/provider-profiles.ts
+init_db();
+init_provider_profile_seeds();
+var TRANSPORTS = new Set(["stdio", "sse", "streamable-http"]);
+var AUTH_TYPES = new Set(["none", "oauth2", "api_key", "bearer_token", "custom"]);
+var TOKEN_MODES = new Set(["none", "user", "workspace", "service"]);
+var BEARER_TOKEN_MODES = new Set(["none", "optional", "required"]);
+var PROVENANCE_SOURCES = new Set(["curated", "official-registry", "npm", "github", "manual"]);
+function safeJsonParse2(value, fallback) {
+  if (typeof value !== "string")
+    return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+function normalizeId(id) {
+  const normalized = id.trim().toLowerCase();
+  if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/.test(normalized)) {
+    throw new Error("Provider profile id must be lowercase kebab-case");
+  }
+  return normalized;
+}
+function parseRow3(row) {
+  const installFallback = safeJsonParse2(row.install_fallback, null);
+  return {
+    id: row.id,
+    displayName: row.display_name,
+    description: row.description || null,
+    endpoint: row.endpoint || null,
+    transport: row.transport,
+    fallbackEndpoints: safeJsonParse2(row.fallback_endpoints, []),
+    authType: row.auth_type,
+    authMetadata: safeJsonParse2(row.auth_metadata, {}),
+    scopes: safeJsonParse2(row.scopes, []),
+    tokenMode: row.token_mode,
+    installFallback,
+    docsUrl: row.docs_url || null,
+    safety: safeJsonParse2(row.safety, {}),
+    provenance: safeJsonParse2(row.provenance, { source: "manual" }),
+    enabled: row.enabled === 1 || row.enabled === true,
+    created_at: row.created_at,
+    updated_at: row.updated_at
+  };
+}
+function listProviderProfiles(options = {}) {
+  const db2 = getDb();
+  const sql = options.enabledOnly ? "SELECT * FROM provider_profiles WHERE enabled = 1 ORDER BY display_name" : "SELECT * FROM provider_profiles ORDER BY display_name";
+  return db2.prepare(sql).all().map(parseRow3);
+}
+function searchProviderProfiles(query, options = {}) {
+  const normalizedQuery = query.trim().toLowerCase();
+  if (!normalizedQuery)
+    return listProviderProfiles(options);
+  return listProviderProfiles(options).filter((profile) => {
+    const searchable = [
+      profile.id,
+      profile.displayName,
+      profile.description ?? "",
+      profile.endpoint ?? "",
+      profile.docsUrl ?? "",
+      profile.provenance.sourceUrl ?? "",
+      profile.provenance.packageName ?? ""
+    ].join(`
+`).toLowerCase();
+    return searchable.includes(normalizedQuery);
+  });
+}
+function getProviderProfile(id) {
+  const db2 = getDb();
+  const row = db2.prepare("SELECT * FROM provider_profiles WHERE id = ?").get(normalizeId(id));
+  return row ? parseRow3(row) : null;
+}
+function installProviderProfile(id, options = {}) {
+  const profile = getProviderProfile(id);
+  if (!profile)
+    throw new Error(`Provider profile "${id}" not found`);
+  if (!profile.enabled)
+    throw new Error(`Provider profile "${id}" is disabled`);
+  const fallback = profile.installFallback;
+  const useFallback = options.useFallback || !profile.endpoint;
+  const command = useFallback ? fallback?.command : fallback?.command ?? "npx";
+  const args = useFallback ? fallback?.args ?? [] : fallback?.args ?? [];
+  if (!command) {
+    throw new Error(`Provider profile "${id}" does not define an install fallback command`);
+  }
+  return addServer({
+    name: options.name ?? profile.displayName,
+    description: profile.description ?? undefined,
+    command,
+    args,
+    transport: useFallback ? "stdio" : profile.transport,
+    url: useFallback ? fallback?.url : profile.endpoint ?? undefined,
+    source: "provider-profile"
+  });
+}
+
 // src/cli/index.tsx
 import * as readline from "readline";
 
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+import process3 from "process";
+class StdioServerTransport {
+  constructor(_stdin = process3.stdin, _stdout = process3.stdout) {
+    this._stdin = _stdin;
+    this._stdout = _stdout;
+    this._readBuffer = new ReadBuffer;
+    this._started = false;
+    this._ondata = (chunk) => {
+      this._readBuffer.append(chunk);
+      this.processReadBuffer();
+    };
+    this._onerror = (error2) => {
+      this.onerror?.(error2);
+    };
+  }
+  async start() {
+    if (this._started) {
+      throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");
+    }
+    this._started = true;
+    this._stdin.on("data", this._ondata);
+    this._stdin.on("error", this._onerror);
+  }
+  processReadBuffer() {
+    while (true) {
+      try {
+        const message = this._readBuffer.readMessage();
+        if (message === null) {
+          break;
+        }
+        this.onmessage?.(message);
+      } catch (error2) {
+        this.onerror?.(error2);
+      }
+    }
+  }
+  async close() {
+    this._stdin.off("data", this._ondata);
+    this._stdin.off("error", this._onerror);
+    const remainingDataListeners = this._stdin.listenerCount("data");
+    if (remainingDataListeners === 0) {
+      this._stdin.pause();
+    }
+    this._readBuffer.clear();
+    this.onclose?.();
+  }
+  send(message) {
+    return new Promise((resolve) => {
+      const json = serializeMessage(message);
+      if (this._stdout.write(json)) {
+        resolve();
+      } else {
+        this._stdout.once("drain", resolve);
+      }
+    });
+  }
+}
+
+// src/mcp/server.ts
+init_dist();
+
 // node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
 class ExperimentalServerTasks {
   constructor(_server) {
@@ -37923,71 +38215,6 @@ var EMPTY_COMPLETION_RESULT = {
   }
 };
 
-// node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
-import process3 from "process";
-class StdioServerTransport {
-  constructor(_stdin = process3.stdin, _stdout = process3.stdout) {
-    this._stdin = _stdin;
-    this._stdout = _stdout;
-    this._readBuffer = new ReadBuffer;
-    this._started = false;
-    this._ondata = (chunk) => {
-      this._readBuffer.append(chunk);
-      this.processReadBuffer();
-    };
-    this._onerror = (error2) => {
-      this.onerror?.(error2);
-    };
-  }
-  async start() {
-    if (this._started) {
-      throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");
-    }
-    this._started = true;
-    this._stdin.on("data", this._ondata);
-    this._stdin.on("error", this._onerror);
-  }
-  processReadBuffer() {
-    while (true) {
-      try {
-        const message = this._readBuffer.readMessage();
-        if (message === null) {
-          break;
-        }
-        this.onmessage?.(message);
-      } catch (error2) {
-        this.onerror?.(error2);
-      }
-    }
-  }
-  async close() {
-    this._stdin.off("data", this._ondata);
-    this._stdin.off("error", this._onerror);
-    const remainingDataListeners = this._stdin.listenerCount("data");
-    if (remainingDataListeners === 0) {
-      this._stdin.pause();
-    }
-    this._readBuffer.clear();
-    this.onclose?.();
-  }
-  send(message) {
-    return new Promise((resolve) => {
-      const json = serializeMessage(message);
-      if (this._stdout.write(json)) {
-        resolve();
-      } else {
-        this._stdout.once("drain", resolve);
-      }
-    });
-  }
-}
-
-// src/mcp/index.ts
-init_dist();
-init_sources();
-init_config2();
-init_db();
-
 // src/lib/version.ts
 import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
 import { dirname as dirname3, join as join10 } from "path";
@@ -38012,463 +38239,659 @@ function readPackageVersion(moduleUrl, fallback = FALLBACK_VERSION) {
   return fallback;
 }
 
-// src/mcp/index.ts
+// src/mcp/tools.ts
+init_sources();
+init_config2();
+init_db();
+var VERSION = readPackageVersion(import.meta.url);
+var mcpsAgents = new Map;
 function redactServerEnv(server) {
   return { ...server, env: {} };
 }
-var VERSION = (() => {
-  return readPackageVersion(import.meta.url);
-})();
-var server = new McpServer({
-  name: "mcps",
-  version: VERSION
-});
-var _mcpsAgents = new Map;
-server.tool("list_servers", "List all registered MCP servers", {}, async () => {
-  const servers = listServers();
-  return {
-    content: [{ type: "text", text: JSON.stringify(servers.map(redactServerEnv), null, 2) }]
-  };
-});
-server.tool("search_registry", "Search the official MCP registry for servers", { query: exports_external2.string().describe("Search query") }, async ({ query }) => {
-  const results = await searchRegistry(query);
-  return {
-    content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
-  };
-});
-server.tool("add_server", "Register a new MCP server", {
-  command: exports_external2.string().describe("Command to run the server (e.g., npx, bunx, node)"),
-  args: exports_external2.array(exports_external2.string()).optional().describe("Arguments for the command"),
-  name: exports_external2.string().optional().describe("Display name"),
-  description: exports_external2.string().optional().describe("Description"),
-  transport: exports_external2.enum(["stdio", "sse", "streamable-http"]).optional().describe("Transport type"),
-  url: exports_external2.string().optional().describe("URL for remote transports"),
-  env: exports_external2.record(exports_external2.string()).optional().describe("Environment variables")
-}, async ({ command, args, name, description, transport, url: url2, env }) => {
-  const entry = addServer({
-    command,
-    args: args || [],
-    name,
-    description,
-    transport,
-    url: url2,
-    env: env || {}
-  });
-  return {
-    content: [{ type: "text", text: JSON.stringify(entry, null, 2) }]
-  };
-});
-server.tool("install_from_registry", "Install an MCP server from the official registry", { id: exports_external2.string().describe("Registry server ID") }, async ({ id }) => {
-  const entry = await installFromRegistry(id);
-  return {
-    content: [{ type: "text", text: JSON.stringify(entry, null, 2) }]
-  };
-});
-server.tool("remove_server", "Remove a registered MCP server", { id: exports_external2.string().describe("Server ID to remove") }, async ({ id }) => {
-  const existing = getServer(id);
-  if (!existing) {
-    return {
-      content: [{ type: "text", text: `Server "${id}" not found.` }],
-      isError: true
-    };
-  }
-  removeServer(id);
-  return {
-    content: [{ type: "text", text: `Removed server: ${existing.name} [${id}]` }]
-  };
-});
-server.tool("enable_server", "Enable a registered MCP server", { id: exports_external2.string().describe("Server ID to enable") }, async ({ id }) => {
-  const existing = getServer(id);
-  if (!existing) {
-    return {
-      content: [{ type: "text", text: `Server "${id}" not found.` }],
-      isError: true
-    };
-  }
-  const entry = enableServer(id);
-  return {
-    content: [{ type: "text", text: JSON.stringify(entry, null, 2) }]
-  };
-});
-server.tool("disable_server", "Disable a registered MCP server", { id: exports_external2.string().describe("Server ID to disable") }, async ({ id }) => {
-  const existing = getServer(id);
-  if (!existing) {
-    return {
-      content: [{ type: "text", text: `Server "${id}" not found.` }],
-      isError: true
-    };
-  }
-  const entry = disableServer(id);
-  return {
-    content: [{ type: "text", text: JSON.stringify(entry, null, 2) }]
-  };
-});
-server.tool("update_server", "Update fields of a registered MCP server", {
-  id: exports_external2.string().describe("Server ID to update"),
-  name: exports_external2.string().optional().describe("New display name"),
-  description: exports_external2.string().optional().describe("New description"),
-  command: exports_external2.string().optional().describe("New command"),
-  args: exports_external2.array(exports_external2.string()).optional().describe("New args list"),
-  transport: exports_external2.enum(["stdio", "sse", "streamable-http"]).optional().describe("New transport type"),
-  url: exports_external2.string().optional().describe("New URL for remote transports")
-}, async ({ id, name, description, command, args, transport, url: url2 }) => {
-  const existing = getServer(id);
-  if (!existing) {
-    return {
-      content: [{ type: "text", text: `Server "${id}" not found.` }],
-      isError: true
-    };
-  }
-  const fields = {};
-  if (name !== undefined)
-    fields.name = name;
-  if (description !== undefined)
-    fields.description = description;
-  if (command !== undefined)
-    fields.command = command;
-  if (args !== undefined)
-    fields.args = args;
-  if (transport !== undefined)
-    fields.transport = transport;
-  if (url2 !== undefined)
-    fields.url = url2;
-  const updated = updateServer(id, fields);
-  return {
-    content: [{ type: "text", text: JSON.stringify(redactServerEnv(updated), null, 2) }]
-  };
-});
-server.tool("list_tools", "List all cached tools across registered servers without connecting. Optionally filter by server_id.", { server_id: exports_external2.string().optional().describe("Server ID to filter by (optional)") }, async ({ server_id }) => {
-  if (server_id) {
-    const tools = getCachedTools(server_id);
-    return {
-      content: [{ type: "text", text: JSON.stringify(tools.map((t) => ({ ...t, server_id })), null, 2) }]
-    };
-  }
-  const servers = listServers();
-  const allTools = [];
-  for (const s of servers) {
-    const tools = getCachedTools(s.id);
-    for (const t of tools) {
-      allTools.push({ server_id: s.id, ...t });
-    }
-  }
-  return {
-    content: [{ type: "text", text: JSON.stringify(allTools, null, 2) }]
-  };
-});
-server.tool("get_server_info", "Get detailed information about a registered MCP server", { id: exports_external2.string().describe("Server ID") }, async ({ id }) => {
-  const entry = getServer(id);
-  if (!entry) {
-    return {
-      content: [{ type: "text", text: `Server "${id}" not found.` }],
-      isError: true
-    };
+function textContent(text) {
+  return { content: [{ type: "text", text }] };
+}
+function jsonContent(value) {
+  return textContent(JSON.stringify(value, null, 2));
+}
+function errorContent(text) {
+  return { ...textContent(text), isError: true };
+}
+function buildMcpTools() {
+  const definitions = [
+    {
+      name: "list_servers",
+      description: "List all registered MCP servers",
+      paramsSchema: {},
+      run: () => jsonContent(listServers().map(redactServerEnv))
+    },
+    {
+      name: "search_registry",
+      description: "Search the official MCP registry for servers",
+      paramsSchema: { query: exports_external2.string().describe("Search query") },
+      run: async ({ query }) => jsonContent(await searchRegistry(String(query)))
+    },
+    {
+      name: "add_server",
+      description: "Register a new MCP server",
+      paramsSchema: {
+        command: exports_external2.string().describe("Command to run the server (e.g., npx, bunx, node)"),
+        args: exports_external2.array(exports_external2.string()).optional().describe("Arguments for the command"),
+        name: exports_external2.string().optional().describe("Display name"),
+        description: exports_external2.string().optional().describe("Description"),
+        transport: exports_external2.enum(["stdio", "sse", "streamable-http"]).optional().describe("Transport type"),
+        url: exports_external2.string().optional().describe("URL for remote transports"),
+        env: exports_external2.record(exports_external2.string()).optional().describe("Environment variables")
+      },
+      run: ({ command, args, name, description, transport, url: url2, env }) => jsonContent(addServer({
+        command: String(command),
+        args: Array.isArray(args) ? args.map(String) : [],
+        name: typeof name === "string" ? name : undefined,
+        description: typeof description === "string" ? description : undefined,
+        transport,
+        url: typeof url2 === "string" ? url2 : undefined,
+        env: isRecordOfStrings(env) ? env : {}
+      }))
+    },
+    {
+      name: "install_from_registry",
+      description: "Install an MCP server from the official registry",
+      paramsSchema: { id: exports_external2.string().describe("Registry server ID") },
+      run: async ({ id }) => jsonContent(await installFromRegistry(String(id)))
+    },
+    {
+      name: "remove_server",
+      description: "Remove a registered MCP server",
+      paramsSchema: { id: exports_external2.string().describe("Server ID to remove") },
+      run: ({ id }) => {
+        const existing = getServer(String(id));
+        if (!existing)
+          return errorContent(`Server "${String(id)}" not found.`);
+        removeServer(String(id));
+        return textContent(`Removed server: ${existing.name} [${String(id)}]`);
+      }
+    },
+    {
+      name: "enable_server",
+      description: "Enable a registered MCP server",
+      paramsSchema: { id: exports_external2.string().describe("Server ID to enable") },
+      run: ({ id }) => {
+        const existing = getServer(String(id));
+        if (!existing)
+          return errorContent(`Server "${String(id)}" not found.`);
+        return jsonContent(enableServer(String(id)));
+      }
+    },
+    {
+      name: "disable_server",
+      description: "Disable a registered MCP server",
+      paramsSchema: { id: exports_external2.string().describe("Server ID to disable") },
+      run: ({ id }) => {
+        const existing = getServer(String(id));
+        if (!existing)
+          return errorContent(`Server "${String(id)}" not found.`);
+        return jsonContent(disableServer(String(id)));
+      }
+    },
+    {
+      name: "update_server",
+      description: "Update fields of a registered MCP server",
+      paramsSchema: {
+        id: exports_external2.string().describe("Server ID to update"),
+        name: exports_external2.string().optional().describe("New display name"),
+        description: exports_external2.string().optional().describe("New description"),
+        command: exports_external2.string().optional().describe("New command"),
+        args: exports_external2.array(exports_external2.string()).optional().describe("New args list"),
+        transport: exports_external2.enum(["stdio", "sse", "streamable-http"]).optional().describe("New transport type"),
+        url: exports_external2.string().optional().describe("New URL for remote transports")
+      },
+      run: ({ id, name, description, command, args, transport, url: url2 }) => {
+        const serverId = String(id);
+        const existing = getServer(serverId);
+        if (!existing)
+          return errorContent(`Server "${serverId}" not found.`);
+        const fields = {};
+        if (typeof name === "string")
+          fields.name = name;
+        if (typeof description === "string")
+          fields.description = description;
+        if (typeof command === "string")
+          fields.command = command;
+        if (Array.isArray(args))
+          fields.args = args.map(String);
+        if (transport === "stdio" || transport === "sse" || transport === "streamable-http")
+          fields.transport = transport;
+        if (typeof url2 === "string")
+          fields.url = url2;
+        return jsonContent(redactServerEnv(updateServer(serverId, fields)));
+      }
+    },
+    {
+      name: "list_tools",
+      description: "List all cached tools across registered servers without connecting. Optionally filter by server_id.",
+      paramsSchema: { server_id: exports_external2.string().optional().describe("Server ID to filter by (optional)") },
+      run: ({ server_id }) => {
+        if (typeof server_id === "string" && server_id) {
+          const toolsForServer = getCachedTools(server_id);
+          return jsonContent(toolsForServer.map((tool) => ({ ...tool, server_id })));
+        }
+        const allTools = [];
+        for (const server of listServers()) {
+          for (const tool of getCachedTools(server.id)) {
+            allTools.push({ server_id: server.id, ...tool });
+          }
+        }
+        return jsonContent(allTools);
+      }
+    },
+    {
+      name: "get_server_info",
+      description: "Get detailed information about a registered MCP server",
+      paramsSchema: { id: exports_external2.string().describe("Server ID") },
+      run: ({ id }) => {
+        const entry = getServer(String(id));
+        if (!entry)
+          return errorContent(`Server "${String(id)}" not found.`);
+        return jsonContent(redactServerEnv(entry));
+      }
+    },
+    {
+      name: "find_mcp_servers",
+      description: "Search for MCP servers across configured sources (official registry, npm, GitHub topics, awesome lists). Use list_sources to see available source IDs.",
+      paramsSchema: {
+        query: exports_external2.string().describe("Search query (e.g., 'filesystem', 'postgres', 'browser')"),
+        sources: exports_external2.array(exports_external2.string()).optional().describe("Source IDs to search (default: all enabled). Use list_sources to get IDs."),
+        limit: exports_external2.number().optional().describe("Max results per source (default: 20)")
+      },
+      run: async ({ query, sources, limit }) => jsonContent(await findServers(String(query), {
+        sources: Array.isArray(sources) ? sources.map(String) : undefined,
+        limit: typeof limit === "number" ? limit : undefined
+      }))
+    },
+    {
+      name: "list_provider_profiles",
+      description: "List curated provider profiles for hosted/common MCP integrations such as Notion and Linear.",
+      paramsSchema: {
+        enabled_only: exports_external2.boolean().optional().describe("Only include enabled provider profiles")
+      },
+      run: ({ enabled_only }) => jsonContent(listProviderProfiles({ enabledOnly: enabled_only === true }))
+    },
+    {
+      name: "search_provider_profiles",
+      description: "Search curated provider profiles separately from raw MCP registry/source search.",
+      paramsSchema: {
+        query: exports_external2.string().describe("Search query such as 'notion', 'linear', or an endpoint URL"),
+        enabled_only: exports_external2.boolean().optional().describe("Only include enabled provider profiles")
+      },
+      run: ({ query, enabled_only }) => jsonContent(searchProviderProfiles(String(query), { enabledOnly: enabled_only === true }))
+    },
+    {
+      name: "get_provider_profile",
+      description: "Get one curated provider profile by ID.",
+      paramsSchema: {
+        id: exports_external2.string().describe("Provider profile ID")
+      },
+      run: ({ id }) => {
+        const profile = getProviderProfile(String(id));
+        if (!profile)
+          return errorContent(`Provider profile "${String(id)}" not found.`);
+        return jsonContent(profile);
+      }
+    },
+    {
+      name: "install_provider_profile",
+      description: "Register a curated provider profile as an MCP server.",
+      paramsSchema: {
+        id: exports_external2.string().describe("Provider profile ID"),
+        name: exports_external2.string().optional().describe("Override registered server name"),
+        use_fallback: exports_external2.boolean().optional().describe("Install the stdio fallback command instead of the direct remote transport")
+      },
+      run: ({ id, name, use_fallback }) => {
+        try {
+          return jsonContent(redactServerEnv(installProviderProfile(String(id), {
+            name: typeof name === "string" ? name : undefined,
+            useFallback: use_fallback === true
+          })));
+        } catch (err) {
+          return errorContent(err.message);
+        }
+      }
+    },
+    {
+      name: "list_sources",
+      description: "List all configured search sources for finding MCP servers",
+      paramsSchema: {},
+      run: () => jsonContent(listSources())
+    },
+    {
+      name: "add_source",
+      description: "Add a new search source for finding MCP servers",
+      paramsSchema: {
+        name: exports_external2.string().describe("Source name"),
+        type: exports_external2.enum(["mcp-registry", "awesome-list", "npm-search", "github-topic"]).describe("Source type"),
+        url: exports_external2.string().describe("Source URL endpoint"),
+        description: exports_external2.string().optional().describe("Description")
+      },
+      run: ({ name, type, url: url2, description }) => jsonContent(addSource({
+        name: String(name),
+        type,
+        url: String(url2),
+        description: typeof description === "string" ? description : undefined
+      }))
+    },
+    {
+      name: "remove_source",
+      description: "Remove a search source by ID",
+      paramsSchema: { id: exports_external2.string().describe("Source ID to remove") },
+      run: ({ id }) => {
+        const sourceId = String(id);
+        const existing = getSource(sourceId);
+        if (!existing)
+          return errorContent(`Source "${sourceId}" not found.`);
+        removeSource(sourceId);
+        return textContent(`Removed source: ${existing.name} [${sourceId}]`);
+      }
+    },
+    {
+      name: "enable_source_finder",
+      description: "Enable a search source",
+      paramsSchema: { id: exports_external2.string().describe("Source ID to enable") },
+      run: ({ id }) => {
+        const sourceId = String(id);
+        const existing = getSource(sourceId);
+        if (!existing)
+          return errorContent(`Source "${sourceId}" not found.`);
+        enableSource(sourceId);
+        return textContent(`Enabled source: ${existing.name}`);
+      }
+    },
+    {
+      name: "disable_source_finder",
+      description: "Disable a search source",
+      paramsSchema: { id: exports_external2.string().describe("Source ID to disable") },
+      run: ({ id }) => {
+        const sourceId = String(id);
+        const existing = getSource(sourceId);
+        if (!existing)
+          return errorContent(`Source "${sourceId}" not found.`);
+        disableSource(sourceId);
+        return textContent(`Disabled source: ${existing.name}`);
+      }
+    },
+    {
+      name: "install_to_agents",
+      description: "Install a registered MCP server into Claude Code, Codex, and/or Gemini",
+      paramsSchema: {
+        id: exports_external2.string().describe("Server ID to install (from list_servers)"),
+        targets: exports_external2.array(exports_external2.enum(["claude", "codex", "gemini"])).optional().describe("Target agents to install into (default: all)")
+      },
+      run: ({ id, targets }) => {
+        const serverId = String(id);
+        const entry = getServer(serverId);
+        if (!entry)
+          return errorContent(`Server "${serverId}" not found.`);
+        const agentTargets = Array.isArray(targets) ? targets : undefined;
+        return jsonContent(installToAgents(entry, agentTargets ?? ["claude", "codex", "gemini"]));
+      }
+    },
+    {
+      name: "list_awesome_servers",
+      description: "List all MCP servers from the curated punkpeye/awesome-mcp-servers GitHub list",
+      paramsSchema: {},
+      run: async () => jsonContent(await listAwesomeServers())
+    },
+    {
+      name: "connect_and_list_tools",
+      description: "Connect to all enabled MCP servers and list their available tools",
+      paramsSchema: {},
+      run: async () => {
+        let liveTools = [];
+        try {
+          await connectAllEnabled();
+          liveTools = listAllTools();
+        } finally {
+          await disconnectAll().catch(() => {
+            return;
+          });
+        }
+        return jsonContent(liveTools);
+      }
+    },
+    {
+      name: "call_upstream_tool",
+      description: `Call a tool on a connected upstream MCP server. Tool name format: server_id${TOOL_PREFIX_SEPARATOR}tool_name`,
+      paramsSchema: {
+        tool_name: exports_external2.string().describe(`Prefixed tool name (server_id${TOOL_PREFIX_SEPARATOR}tool_name)`),
+        arguments: exports_external2.record(exports_external2.unknown()).optional().describe("Tool arguments as key-value pairs")
+      },
+      run: async ({ tool_name, arguments: args }) => {
+        try {
+          const toolName = String(tool_name);
+          const sepIdx = toolName.indexOf(TOOL_PREFIX_SEPARATOR);
+          if (sepIdx === -1)
+            return errorContent(`Error: Invalid tool name "${toolName}"`);
+          const serverId = toolName.slice(0, sepIdx);
+          const entry = getServer(serverId);
+          if (!entry)
+            return errorContent(`Error: Server "${serverId}" not found.`);
+          if (!entry.enabled)
+            return errorContent(`Error: Server "${serverId}" is disabled.`);
+          await connectToServer(entry);
+          const result = await callTool(toolName, readRecord(args));
+          return { content: result.content };
+        } catch (error2) {
+          return errorContent(`Error: ${error2.message}`);
+        }
+      }
+    },
+    {
+      name: "diagnose_server",
+      description: "Run health checks on a registered MCP server",
+      paramsSchema: { id: exports_external2.string().describe("Server ID") },
+      run: async ({ id }) => {
+        const serverId = String(id);
+        const entry = getServer(serverId);
+        if (!entry)
+          return errorContent(`Server "${serverId}" not found.`);
+        return jsonContent(await diagnoseServer(entry));
+      }
+    },
+    {
+      name: "list_machines",
+      description: "List registered fleet machines",
+      paramsSchema: {
+        enabled_only: exports_external2.boolean().optional().describe("When true, only return enabled machines")
+      },
+      run: ({ enabled_only }) => jsonContent(listMachines().filter((machine) => enabled_only === true ? machine.enabled : true))
+    },
+    {
+      name: "add_machine",
+      description: "Register a machine for fleet health checks and installs",
+      paramsSchema: {
+        host: exports_external2.string().describe("Hostname or SSH target"),
+        id: exports_external2.string().optional().describe("Stable machine ID"),
+        name: exports_external2.string().optional().describe("Display name"),
+        username: exports_external2.string().optional().describe("SSH username"),
+        port: exports_external2.number().int().min(1).max(65535).optional().describe("SSH port"),
+        platform: exports_external2.enum(["linux", "darwin", "unknown"]).optional().describe("Machine platform"),
+        arch: exports_external2.enum(["arm64", "x64", "unknown"]).optional().describe("Machine architecture"),
+        bun_path: exports_external2.string().optional().describe("Explicit path to bun on the remote machine"),
+        npm_path: exports_external2.string().optional().describe("Explicit path to npm on the remote machine"),
+        installer: exports_external2.enum(["auto", "bun", "npm"]).optional().describe("Preferred installer"),
+        ssh_key_path: exports_external2.string().optional().describe("SSH private key path"),
+        enabled: exports_external2.boolean().optional().describe("Whether the machine should be enabled")
+      },
+      run: ({ host, id, name, username, port, platform: platform2, arch, bun_path, npm_path, installer, ssh_key_path, enabled }) => jsonContent(addMachine({
+        host: String(host),
+        id: typeof id === "string" ? id : undefined,
+        name: typeof name === "string" ? name : undefined,
+        username: typeof username === "string" ? username : undefined,
+        port: typeof port === "number" ? port : undefined,
+        platform: platform2,
+        arch,
+        bun_path: typeof bun_path === "string" ? bun_path : undefined,
+        npm_path: typeof npm_path === "string" ? npm_path : undefined,
+        installer,
+        ssh_key_path: typeof ssh_key_path === "string" ? ssh_key_path : undefined,
+        enabled: typeof enabled === "boolean" ? enabled : undefined
+      }))
+    },
+    {
+      name: "remove_machine",
+      description: "Remove a registered machine",
+      paramsSchema: { id: exports_external2.string().describe("Machine ID to remove") },
+      run: ({ id }) => {
+        const machineId = String(id);
+        const machine = getMachine(machineId);
+        if (!machine)
+          return errorContent(`Machine "${machineId}" not found.`);
+        removeMachine(machineId);
+        return jsonContent({ removed: true, machine });
+      }
+    },
+    {
+      name: "seed_default_machines",
+      description: "Seed the standard spark/apple machine inventory",
+      paramsSchema: {},
+      run: () => jsonContent(seedDefaultMachines())
+    },
+    {
+      name: "list_hasna_mcp_catalog",
+      description: "List the discovered @hasna MCP package catalog",
+      paramsSchema: {
+        packages: exports_external2.array(exports_external2.string()).optional().describe("Optional package-name filter"),
+        refresh: exports_external2.boolean().optional().describe("Refresh npm metadata instead of using cache")
+      },
+      run: async ({ packages, refresh }) => {
+        const catalog = await listHasnaMcpCatalog({ refresh: refresh === true });
+        const filtered = Array.isArray(packages) && packages.length > 0 ? catalog.filter((entry) => packages.map(String).includes(entry.name)) : catalog;
+        return jsonContent(filtered);
+      }
+    },
+    {
+      name: "fleet_health",
+      description: "Run fleet-wide MCP health checks across registered machines",
+      paramsSchema: {
+        machine_ids: exports_external2.array(exports_external2.string()).optional().describe("Optional machine IDs to check"),
+        packages: exports_external2.array(exports_external2.string()).optional().describe("Optional @hasna package-name filter"),
+        refresh_catalog: exports_external2.boolean().optional().describe("Refresh npm metadata before checking"),
+        timeout_ms: exports_external2.number().int().min(1000).optional().describe("Remote timeout in milliseconds")
+      },
+      run: async ({ machine_ids, packages, refresh_catalog, timeout_ms }) => jsonContent(await runFleetHealthCheck({
+        machineIds: Array.isArray(machine_ids) ? machine_ids.map(String) : undefined,
+        packages: Array.isArray(packages) ? packages.map(String) : undefined,
+        refreshCatalog: refresh_catalog === true,
+        timeoutMs: typeof timeout_ms === "number" ? timeout_ms : undefined
+      }))
+    },
+    {
+      name: "fleet_install",
+      description: "Batch-install missing or outdated @hasna MCP packages across machines",
+      paramsSchema: {
+        machine_ids: exports_external2.array(exports_external2.string()).optional().describe("Optional machine IDs to target"),
+        packages: exports_external2.array(exports_external2.string()).optional().describe("Optional @hasna package-name filter"),
+        mode: exports_external2.enum(["missing", "missing-or-outdated", "all"]).optional().describe("Install selection mode"),
+        installer: exports_external2.enum(["auto", "bun", "npm"]).optional().describe("Override installer"),
+        refresh_catalog: exports_external2.boolean().optional().describe("Refresh npm metadata before installing"),
+        timeout_ms: exports_external2.number().int().min(1000).optional().describe("Remote timeout in milliseconds")
+      },
+      run: async ({ machine_ids, packages, mode, installer, refresh_catalog, timeout_ms }) => jsonContent(await runFleetInstall({
+        machineIds: Array.isArray(machine_ids) ? machine_ids.map(String) : undefined,
+        packages: Array.isArray(packages) ? packages.map(String) : undefined,
+        mode: mode === "missing" || mode === "missing-or-outdated" || mode === "all" ? mode : undefined,
+        installer: installer === "auto" || installer === "bun" || installer === "npm" ? installer : undefined,
+        refreshCatalog: refresh_catalog === true,
+        timeoutMs: typeof timeout_ms === "number" ? timeout_ms : undefined
+      }))
+    },
+    {
+      name: "send_feedback",
+      description: "Send feedback about this service",
+      paramsSchema: {
+        message: exports_external2.string().describe("Feedback message"),
+        email: exports_external2.string().optional().describe("Contact email (optional)"),
+        category: exports_external2.enum(["bug", "feature", "general"]).optional().describe("Feedback category")
+      },
+      run: ({ message, email: email2, category }) => {
+        const adapter = getAdapter();
+        adapter.run("INSERT INTO feedback (message, email, category, version) VALUES (?, ?, ?, ?)", String(message), typeof email2 === "string" ? email2 : null, typeof category === "string" ? category : "general", VERSION);
+        return textContent("Feedback saved. Thank you!");
+      }
+    },
+    {
+      name: "register_agent",
+      description: "Register an agent session. Returns agent_id. Auto-triggers a heartbeat.",
+      paramsSchema: {
+        name: exports_external2.string(),
+        session_id: exports_external2.string().optional()
+      },
+      run: ({ name, session_id }) => {
+        const agentName = String(name);
+        const existing = [...mcpsAgents.values()].find((agent2) => agent2.name === agentName);
+        if (existing) {
+          existing.last_seen_at = new Date().toISOString();
+          if (typeof session_id === "string")
+            existing.session_id = session_id;
+          return jsonContent(existing);
+        }
+        const id = Math.random().toString(36).slice(2, 10);
+        const agent = {
+          id,
+          name: agentName,
+          session_id: typeof session_id === "string" ? session_id : undefined,
+          last_seen_at: new Date().toISOString()
+        };
+        mcpsAgents.set(id, agent);
+        return jsonContent(agent);
+      }
+    },
+    {
+      name: "heartbeat",
+      description: "Update last_seen_at to signal agent is active.",
+      paramsSchema: { agent_id: exports_external2.string() },
+      run: ({ agent_id }) => {
+        const agentId = String(agent_id);
+        const agent = mcpsAgents.get(agentId);
+        if (!agent)
+          return errorContent(`Agent not found: ${agentId}`);
+        agent.last_seen_at = new Date().toISOString();
+        return jsonContent({ agent_id: agent.id, last_seen_at: agent.last_seen_at });
+      }
+    },
+    {
+      name: "set_focus",
+      description: "Set active project context for this agent session.",
+      paramsSchema: {
+        agent_id: exports_external2.string(),
+        project_id: exports_external2.string().optional()
+      },
+      run: ({ agent_id, project_id }) => {
+        const agentId = String(agent_id);
+        const agent = mcpsAgents.get(agentId);
+        if (!agent)
+          return errorContent(`Agent not found: ${agentId}`);
+        agent.project_id = typeof project_id === "string" ? project_id : undefined;
+        return jsonContent({ agent_id: agent.id, project_id: agent.project_id ?? null });
+      }
+    },
+    {
+      name: "list_agents",
+      description: "List all registered agents.",
+      paramsSchema: {},
+      run: () => jsonContent([...mcpsAgents.values()])
+    }
+  ];
+  return definitions.map((definition) => ({
+    ...definition,
+    inputSchema: zodRawShapeToJsonSchema(definition.paramsSchema)
+  }));
+}
+var tools = buildMcpTools();
+function registerMcpTools(server, toolDefinitions = buildMcpTools()) {
+  for (const tool of toolDefinitions) {
+    server.tool(tool.name, tool.description, tool.paramsSchema ?? {}, async (input) => tool.run(readRecord(input)));
   }
-  return {
-    content: [{ type: "text", text: JSON.stringify(redactServerEnv(entry), null, 2) }]
-  };
-});
-server.tool("find_mcp_servers", "Search for MCP servers across configured sources (official registry, npm, GitHub topics, awesome lists). Use list_sources to see available source IDs.", {
-  query: exports_external2.string().describe("Search query (e.g. 'filesystem', 'postgres', 'browser')"),
-  sources: exports_external2.array(exports_external2.string()).optional().describe("Source IDs to search (default: all enabled). Use list_sources to get IDs."),
-  limit: exports_external2.number().optional().describe("Max results per source (default: 20)")
-}, async ({ query, sources, limit }) => {
-  const results = await findServers(query, { sources, limit });
-  return {
-    content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
-  };
-});
-server.tool("list_sources", "List all configured search sources for finding MCP servers", {}, async () => {
-  const sources = listSources();
-  return {
-    content: [{ type: "text", text: JSON.stringify(sources, null, 2) }]
-  };
-});
-server.tool("add_source", "Add a new search source for finding MCP servers", {
-  name: exports_external2.string().describe("Source name"),
-  type: exports_external2.enum(["mcp-registry", "awesome-list", "npm-search", "github-topic"]).describe("Source type"),
-  url: exports_external2.string().describe("Source URL endpoint"),
-  description: exports_external2.string().optional().describe("Description")
-}, async ({ name, type, url: url2, description }) => {
-  const source = addSource({ name, type, url: url2, description });
-  return {
-    content: [{ type: "text", text: JSON.stringify(source, null, 2) }]
-  };
-});
-server.tool("remove_source", "Remove a search source by ID", { id: exports_external2.string().describe("Source ID to remove") }, async ({ id }) => {
-  const existing = getSource(id);
-  if (!existing) {
-    return {
-      content: [{ type: "text", text: `Source "${id}" not found.` }],
-      isError: true
-    };
+  return toolDefinitions;
+}
+function zodRawShapeToJsonSchema(shape) {
+  const properties = {};
+  const required2 = [];
+  for (const [key, schema] of Object.entries(shape)) {
+    properties[key] = zodSchemaToJsonSchema(schema);
+    if (!isOptionalSchema(schema))
+      required2.push(key);
   }
-  removeSource(id);
   return {
-    content: [{ type: "text", text: `Removed source: ${existing.name} [${id}]` }]
+    type: "object",
+    properties,
+    ...required2.length > 0 ? { required: required2 } : {},
+    additionalProperties: false
   };
-});
-server.tool("enable_source_finder", "Enable a search source", { id: exports_external2.string().describe("Source ID to enable") }, async ({ id }) => {
-  const existing = getSource(id);
-  if (!existing) {
-    return {
-      content: [{ type: "text", text: `Source "${id}" not found.` }],
-      isError: true
-    };
+}
+function zodSchemaToJsonSchema(schema) {
+  const def = schema._def;
+  const typeName = String(def?.typeName ?? "");
+  const description = schema.description ? { description: schema.description } : {};
+  if (typeName === exports_external2.ZodFirstPartyTypeKind.ZodOptional || typeName === exports_external2.ZodFirstPartyTypeKind.ZodDefault) {
+    return { ...asJsonSchemaObject(zodSchemaToJsonSchema(def.innerType)), ...description };
   }
-  enableSource(id);
-  return {
-    content: [{ type: "text", text: `Enabled source: ${existing.name}` }]
-  };
-});
-server.tool("disable_source_finder", "Disable a search source", { id: exports_external2.string().describe("Source ID to disable") }, async ({ id }) => {
-  const existing = getSource(id);
-  if (!existing) {
-    return {
-      content: [{ type: "text", text: `Source "${id}" not found.` }],
-      isError: true
-    };
+  if (typeName === exports_external2.ZodFirstPartyTypeKind.ZodNullable) {
+    return { ...asJsonSchemaObject(zodSchemaToJsonSchema(def.innerType)), nullable: true, ...description };
   }
-  disableSource(id);
-  return {
-    content: [{ type: "text", text: `Disabled source: ${existing.name}` }]
-  };
-});
-server.tool("install_to_agents", "Install a registered MCP server into Claude Code, Codex, and/or Gemini", {
-  id: exports_external2.string().describe("Server ID to install (from list_servers)"),
-  targets: exports_external2.array(exports_external2.enum(["claude", "codex", "gemini"])).optional().describe("Target agents to install into (default: all)")
-}, async ({ id, targets }) => {
-  const entry = getServer(id);
-  if (!entry) {
-    return {
-      content: [{ type: "text", text: `Server "${id}" not found.` }],
-      isError: true
-    };
+  if (typeName === exports_external2.ZodFirstPartyTypeKind.ZodString) {
+    return { type: "string", ...description };
   }
-  const agentTargets = targets ?? ["claude", "codex", "gemini"];
-  const results = installToAgents(entry, agentTargets);
-  return {
-    content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
-  };
-});
-server.tool("list_awesome_servers", "List all MCP servers from the curated punkpeye/awesome-mcp-servers GitHub list", {}, async () => {
-  const results = await listAwesomeServers();
-  return {
-    content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
-  };
-});
-server.tool("connect_and_list_tools", "Connect to all enabled MCP servers and list their available tools", {}, async () => {
-  let tools = [];
-  try {
-    await connectAllEnabled();
-    tools = listAllTools();
-  } finally {
-    await disconnectAll().catch(() => {
-      return;
-    });
+  if (typeName === exports_external2.ZodFirstPartyTypeKind.ZodBoolean) {
+    return { type: "boolean", ...description };
   }
-  return {
-    content: [{ type: "text", text: JSON.stringify(tools, null, 2) }]
-  };
-});
-server.tool("call_upstream_tool", `Call a tool on a connected upstream MCP server. Tool name format: server_id${TOOL_PREFIX_SEPARATOR}tool_name`, {
-  tool_name: exports_external2.string().describe(`Prefixed tool name (server_id${TOOL_PREFIX_SEPARATOR}tool_name)`),
-  arguments: exports_external2.record(exports_external2.unknown()).optional().describe("Tool arguments as key-value pairs")
-}, async ({ tool_name, arguments: args }) => {
-  try {
-    const sepIdx = tool_name.indexOf(TOOL_PREFIX_SEPARATOR);
-    if (sepIdx === -1) {
-      return {
-        content: [{ type: "text", text: `Error: Invalid tool name "${tool_name}"` }],
-        isError: true
-      };
-    }
-    const serverId = tool_name.slice(0, sepIdx);
-    const entry = getServer(serverId);
-    if (!entry) {
-      return {
-        content: [{ type: "text", text: `Error: Server "${serverId}" not found.` }],
-        isError: true
-      };
-    }
-    if (!entry.enabled) {
-      return {
-        content: [{ type: "text", text: `Error: Server "${serverId}" is disabled.` }],
-        isError: true
-      };
-    }
-    await connectToServer(entry);
-    const result = await callTool(tool_name, args || {});
-    return { content: result.content };
-  } catch (err) {
-    return {
-      content: [{ type: "text", text: `Error: ${err.message}` }],
-      isError: true
-    };
+  if (typeName === exports_external2.ZodFirstPartyTypeKind.ZodUnknown || typeName === exports_external2.ZodFirstPartyTypeKind.ZodAny) {
+    return Object.keys(description).length > 0 ? description : true;
   }
-});
-server.tool("diagnose_server", "Run health checks on a registered MCP server", { id: exports_external2.string().describe("Server ID") }, async ({ id }) => {
-  const entry = getServer(id);
-  if (!entry)
-    return { content: [{ type: "text", text: `Server "${id}" not found.` }], isError: true };
-  const report = await diagnoseServer(entry);
-  return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
-});
-server.tool("list_machines", "List registered fleet machines", {
-  enabled_only: exports_external2.boolean().optional().describe("When true, only return enabled machines")
-}, async ({ enabled_only }) => {
-  const machines = listMachines().filter((machine) => enabled_only ? machine.enabled : true);
-  return {
-    content: [{ type: "text", text: JSON.stringify(machines, null, 2) }]
-  };
-});
-server.tool("add_machine", "Register a machine for fleet health checks and installs", {
-  host: exports_external2.string().describe("Hostname or SSH target"),
-  id: exports_external2.string().optional().describe("Stable machine ID"),
-  name: exports_external2.string().optional().describe("Display name"),
-  username: exports_external2.string().optional().describe("SSH username"),
-  port: exports_external2.number().int().min(1).max(65535).optional().describe("SSH port"),
-  platform: exports_external2.enum(["linux", "darwin", "unknown"]).optional().describe("Machine platform"),
-  arch: exports_external2.enum(["arm64", "x64", "unknown"]).optional().describe("Machine architecture"),
-  bun_path: exports_external2.string().optional().describe("Explicit path to bun on the remote machine"),
-  npm_path: exports_external2.string().optional().describe("Explicit path to npm on the remote machine"),
-  installer: exports_external2.enum(["auto", "bun", "npm"]).optional().describe("Preferred installer"),
-  ssh_key_path: exports_external2.string().optional().describe("SSH private key path"),
-  enabled: exports_external2.boolean().optional().describe("Whether the machine should be enabled")
-}, async ({ host, id, name, username, port, platform: platform2, arch, bun_path, npm_path, installer, ssh_key_path, enabled }) => {
-  const machine = addMachine({
-    host,
-    id,
-    name,
-    username,
-    port,
-    platform: platform2,
-    arch,
-    bun_path,
-    npm_path,
-    installer,
-    ssh_key_path,
-    enabled
-  });
-  return {
-    content: [{ type: "text", text: JSON.stringify(machine, null, 2) }]
-  };
-});
-server.tool("remove_machine", "Remove a registered machine", { id: exports_external2.string().describe("Machine ID to remove") }, async ({ id }) => {
-  const machine = getMachine(id);
-  if (!machine) {
-    return {
-      content: [{ type: "text", text: `Machine "${id}" not found.` }],
-      isError: true
+  if (typeName === exports_external2.ZodFirstPartyTypeKind.ZodNumber) {
+    const checks4 = Array.isArray(def.checks) ? def.checks : [];
+    const schemaJson = {
+      type: checks4.some((check2) => check2.kind === "int") ? "integer" : "number",
+      ...description
     };
+    for (const check2 of checks4) {
+      if (check2.kind === "min")
+        schemaJson.minimum = check2.value;
+      if (check2.kind === "max")
+        schemaJson.maximum = check2.value;
+    }
+    return schemaJson;
   }
-  removeMachine(id);
-  return {
-    content: [{ type: "text", text: JSON.stringify({ removed: true, machine }, null, 2) }]
-  };
-});
-server.tool("seed_default_machines", "Seed the standard spark/apple machine inventory", {}, async () => {
-  const machines = seedDefaultMachines();
-  return {
-    content: [{ type: "text", text: JSON.stringify(machines, null, 2) }]
-  };
-});
-server.tool("list_hasna_mcp_catalog", "List the discovered @hasna MCP package catalog", {
-  packages: exports_external2.array(exports_external2.string()).optional().describe("Optional package-name filter"),
-  refresh: exports_external2.boolean().optional().describe("Refresh npm metadata instead of using cache")
-}, async ({ packages, refresh }) => {
-  const catalog = await listHasnaMcpCatalog({ refresh });
-  const filtered = packages?.length ? catalog.filter((entry) => packages.includes(entry.name)) : catalog;
-  return {
-    content: [{ type: "text", text: JSON.stringify(filtered, null, 2) }]
-  };
-});
-server.tool("fleet_health", "Run fleet-wide MCP health checks across registered machines", {
-  machine_ids: exports_external2.array(exports_external2.string()).optional().describe("Optional machine IDs to check"),
-  packages: exports_external2.array(exports_external2.string()).optional().describe("Optional @hasna package-name filter"),
-  refresh_catalog: exports_external2.boolean().optional().describe("Refresh npm metadata before checking"),
-  timeout_ms: exports_external2.number().int().min(1000).optional().describe("Remote timeout in milliseconds")
-}, async ({ machine_ids, packages, refresh_catalog, timeout_ms }) => {
-  const reports = await runFleetHealthCheck({
-    machineIds: machine_ids,
-    packages,
-    refreshCatalog: refresh_catalog,
-    timeoutMs: timeout_ms
-  });
-  return {
-    content: [{ type: "text", text: JSON.stringify(reports, null, 2) }]
-  };
-});
-server.tool("fleet_install", "Batch-install missing or outdated @hasna MCP packages across machines", {
-  machine_ids: exports_external2.array(exports_external2.string()).optional().describe("Optional machine IDs to target"),
-  packages: exports_external2.array(exports_external2.string()).optional().describe("Optional @hasna package-name filter"),
-  mode: exports_external2.enum(["missing", "missing-or-outdated", "all"]).optional().describe("Install selection mode"),
-  installer: exports_external2.enum(["auto", "bun", "npm"]).optional().describe("Override installer"),
-  refresh_catalog: exports_external2.boolean().optional().describe("Refresh npm metadata before installing"),
-  timeout_ms: exports_external2.number().int().min(1000).optional().describe("Remote timeout in milliseconds")
-}, async ({ machine_ids, packages, mode, installer, refresh_catalog, timeout_ms }) => {
-  const reports = await runFleetInstall({
-    machineIds: machine_ids,
-    packages,
-    mode,
-    installer,
-    refreshCatalog: refresh_catalog,
-    timeoutMs: timeout_ms
+  if (typeName === exports_external2.ZodFirstPartyTypeKind.ZodEnum) {
+    return { type: "string", enum: def.values, ...description };
+  }
+  if (typeName === exports_external2.ZodFirstPartyTypeKind.ZodArray) {
+    return { type: "array", items: zodSchemaToJsonSchema(def.type), ...description };
+  }
+  if (typeName === exports_external2.ZodFirstPartyTypeKind.ZodRecord) {
+    const valueType = def.valueType ? zodSchemaToJsonSchema(def.valueType) : true;
+    return { type: "object", additionalProperties: valueType, ...description };
+  }
+  if (typeName === exports_external2.ZodFirstPartyTypeKind.ZodObject) {
+    const objectShape = typeof def.shape === "function" ? def.shape() : def.shape;
+    return { ...zodRawShapeToJsonSchema(objectShape ?? {}), ...description };
+  }
+  return Object.keys(description).length > 0 ? description : {};
+}
+function asJsonSchemaObject(schema) {
+  return typeof schema === "boolean" ? {} : schema;
+}
+function isOptionalSchema(schema) {
+  const def = schema._def;
+  const typeName = String(def?.typeName ?? "");
+  return typeName === exports_external2.ZodFirstPartyTypeKind.ZodOptional || typeName === exports_external2.ZodFirstPartyTypeKind.ZodDefault;
+}
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function isRecordOfStrings(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  return Object.values(value).every((item) => typeof item === "string");
+}
+
+// src/mcp/server.ts
+var VERSION2 = readPackageVersion(import.meta.url);
+function createMcpServer(options = {}) {
+  const server = new McpServer({
+    name: options.name ?? "mcps",
+    version: options.version ?? VERSION2
   });
-  return {
-    content: [{ type: "text", text: JSON.stringify(reports, null, 2) }]
-  };
-});
-server.tool("send_feedback", "Send feedback about this service", {
-  message: exports_external2.string().describe("Feedback message"),
-  email: exports_external2.string().optional().describe("Contact email (optional)"),
-  category: exports_external2.enum(["bug", "feature", "general"]).optional().describe("Feedback category")
-}, async (params) => {
-  const adapter = getAdapter();
-  adapter.run("INSERT INTO feedback (message, email, category, version) VALUES (?, ?, ?, ?)", params.message, params.email || null, params.category || "general", VERSION);
-  return { content: [{ type: "text", text: "Feedback saved. Thank you!" }] };
-});
-server.tool("register_agent", "Register an agent session. Returns agent_id. Auto-triggers a heartbeat.", {
-  name: exports_external2.string(),
-  session_id: exports_external2.string().optional()
-}, async (params) => {
-  const existing = [..._mcpsAgents.values()].find((a) => a.name === params.name);
-  if (existing) {
-    existing.last_seen_at = new Date().toISOString();
-    if (params.session_id)
-      existing.session_id = params.session_id;
-    return { content: [{ type: "text", text: JSON.stringify(existing) }] };
-  }
-  const id = Math.random().toString(36).slice(2, 10);
-  const ag = { id, name: params.name, session_id: params.session_id, last_seen_at: new Date().toISOString() };
-  _mcpsAgents.set(id, ag);
-  return { content: [{ type: "text", text: JSON.stringify(ag) }] };
-});
-server.tool("heartbeat", "Update last_seen_at to signal agent is active.", {
-  agent_id: exports_external2.string()
-}, async (params) => {
-  const ag = _mcpsAgents.get(params.agent_id);
-  if (!ag)
-    return { content: [{ type: "text", text: `Agent not found: ${params.agent_id}` }], isError: true };
-  ag.last_seen_at = new Date().toISOString();
-  return { content: [{ type: "text", text: JSON.stringify({ agent_id: ag.id, last_seen_at: ag.last_seen_at }) }] };
-});
-server.tool("set_focus", "Set active project context for this agent session.", {
-  agent_id: exports_external2.string(),
-  project_id: exports_external2.string().optional()
-}, async (params) => {
-  const ag = _mcpsAgents.get(params.agent_id);
-  if (!ag)
-    return { content: [{ type: "text", text: `Agent not found: ${params.agent_id}` }], isError: true };
-  ag.project_id = params.project_id;
-  return { content: [{ type: "text", text: JSON.stringify({ agent_id: ag.id, project_id: ag.project_id ?? null }) }] };
-});
-server.tool("list_agents", "List all registered agents.", {}, async () => {
-  return { content: [{ type: "text", text: JSON.stringify([..._mcpsAgents.values()]) }] };
-});
+  registerMcpTools(server, options.tools);
+  if (options.cloudTools !== false) {
+    registerCloudTools(server, "mcps");
+  }
+  return server;
+}
+
+// src/mcp/index.ts
 async function startMcpServer() {
+  const server = createMcpServer();
   const transport = new StdioServerTransport;
-  registerCloudTools(server, "mcps");
   await server.connect(transport);
 }
 var isDirectRun = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("/mcp/index.ts") || process.argv[1]?.endsWith("/bin/mcp.js");
@@ -38485,8 +38908,8 @@ import { join as join11, dirname as dirname4, extname, resolve, relative as rela
 import { fileURLToPath as fileURLToPath2 } from "url";
 init_sources();
 init_db();
-function redactServer(server2) {
-  return { ...server2, env: {} };
+function redactServer(server) {
+  return { ...server, env: {} };
 }
 function resolveDashboardDir() {
   const candidates = [];
@@ -38635,7 +39058,7 @@ Dashboard not found at: ${dashboardDir}`);
     console.error(`  cd dashboard && bun install && bun run build
 `);
   }
-  const server2 = Bun.serve({
+  const server = Bun.serve({
     port,
     hostname: host,
     async fetch(req) {
@@ -38706,8 +39129,8 @@ Dashboard not found at: ${dashboardDir}`);
         const entry = getServer(id);
         if (!entry)
           return json({ error: `Server '${id}' not found` }, 404, port);
-        const tools = getCachedTools(id);
-        return json({ ...redactServer(entry), toolCount: tools.length, tools }, 200, port);
+        const tools2 = getCachedTools(id);
+        return json({ ...redactServer(entry), toolCount: tools2.length, tools: tools2 }, 200, port);
       }
       if (singleMatch && method === "DELETE") {
         const id = singleMatch[1];
@@ -38835,8 +39258,8 @@ Dashboard not found at: ${dashboardDir}`);
         const entry = getServer(id);
         if (!entry)
           return json({ error: `Server '${id}' not found` }, 404, port);
-        const tools = getCachedTools(id);
-        return json(tools, 200, port);
+        const tools2 = getCachedTools(id);
+        return json(tools2, 200, port);
       }
       const serverCallMatch = path.match(/^\/api\/servers\/([^/]+)\/call$/);
       if (serverCallMatch && method === "POST") {
@@ -39019,7 +39442,7 @@ Dashboard not found at: ${dashboardDir}`);
     }
   });
   const shutdown = () => {
-    server2.stop();
+    server.stop();
     closeDb();
     process.exit(0);
   };
@@ -39532,18 +39955,18 @@ var build_default = Spinner;
 
 // src/cli/components/ServerDetail.tsx
 import { jsxDEV as jsxDEV2, Fragment } from "react/jsx-dev-runtime";
-function ServerDetail({ server: server2, onSelectTool, onBack }) {
-  const [tools, setTools] = useState3([]);
+function ServerDetail({ server, onSelectTool, onBack }) {
+  const [tools2, setTools] = useState3([]);
   const [loading, setLoading] = useState3(false);
   const [error2, setError] = useState3(null);
-  const cachedTools = getCachedTools(server2.id);
+  const cachedTools = getCachedTools(server.id);
   const cachedKey = cachedTools.map((t) => `${t.name}|${t.description}|${JSON.stringify(t.input_schema)}`).join(";");
   useEffect3(() => {
     setLoading(false);
     setError(null);
     if (cachedTools.length > 0) {
       setTools(cachedTools.map((t) => ({
-        server_id: server2.id,
+        server_id: server.id,
         name: t.name,
         description: t.description,
         input_schema: t.input_schema
@@ -39551,12 +39974,12 @@ function ServerDetail({ server: server2, onSelectTool, onBack }) {
     } else {
       setTools([]);
     }
-  }, [server2.id, cachedKey]);
+  }, [server.id, cachedKey]);
   const handleConnect = async () => {
     setLoading(true);
     setError(null);
     try {
-      const conn = await connectToServer(server2);
+      const conn = await connectToServer(server);
       setTools(conn.tools);
     } catch (err) {
       setError(err.message);
@@ -39565,8 +39988,8 @@ function ServerDetail({ server: server2, onSelectTool, onBack }) {
     }
   };
   const items = [
-    ...tools.length === 0 && !loading ? [{ label: "Connect & fetch tools", value: "__connect" }] : [],
-    ...tools.map((t) => ({
+    ...tools2.length === 0 && !loading ? [{ label: "Connect & fetch tools", value: "__connect" }] : [],
+    ...tools2.map((t) => ({
       label: `${t.name} \u2014 ${t.description || "No description"}`,
       value: t.name,
       tool: t
@@ -39575,7 +39998,7 @@ function ServerDetail({ server: server2, onSelectTool, onBack }) {
   ];
   const handleSelect = (item) => {
     if (item.value === "__back") {
-      disconnectServer(server2.id);
+      disconnectServer(server.id);
       onBack();
     } else if (item.value === "__connect") {
       handleConnect();
@@ -39588,36 +40011,36 @@ function ServerDetail({ server: server2, onSelectTool, onBack }) {
     children: [
       /* @__PURE__ */ jsxDEV2(Text5, {
         bold: true,
-        children: server2.name
+        children: server.name
       }, undefined, false, undefined, this),
       /* @__PURE__ */ jsxDEV2(Text5, {
         dimColor: true,
         children: [
           "ID: ",
-          server2.id
+          server.id
         ]
       }, undefined, true, undefined, this),
       /* @__PURE__ */ jsxDEV2(Text5, {
         dimColor: true,
         children: [
           "Status: ",
-          server2.enabled ? "enabled" : "disabled",
+          server.enabled ? "enabled" : "disabled",
           " | Transport: ",
-          server2.transport
+          server.transport
         ]
       }, undefined, true, undefined, this),
       /* @__PURE__ */ jsxDEV2(Text5, {
         dimColor: true,
         children: [
           "Command: ",
-          server2.command,
+          server.command,
           " ",
-          server2.args.join(" ")
+          server.args.join(" ")
         ]
       }, undefined, true, undefined, this),
-      server2.description && /* @__PURE__ */ jsxDEV2(Text5, {
+      server.description && /* @__PURE__ */ jsxDEV2(Text5, {
         dimColor: true,
-        children: server2.description
+        children: server.description
       }, undefined, false, undefined, this),
       /* @__PURE__ */ jsxDEV2(Box4, {
         marginTop: 1,
@@ -39639,7 +40062,7 @@ function ServerDetail({ server: server2, onSelectTool, onBack }) {
           children: [
             /* @__PURE__ */ jsxDEV2(Text5, {
               bold: true,
-              children: tools.length > 0 ? `Tools (${tools.length}):` : "Tools:"
+              children: tools2.length > 0 ? `Tools (${tools2.length}):` : "Tools:"
             }, undefined, false, undefined, this),
             /* @__PURE__ */ jsxDEV2(SelectInput_default, {
               items,
@@ -39783,8 +40206,8 @@ function SearchView({ onBack }) {
     setInstalling(item.value);
     setMessage(null);
     try {
-      const server2 = await installFromRegistry(item.value);
-      setMessage(`Installed: ${server2.name} [${server2.id}]`);
+      const server = await installFromRegistry(item.value);
+      setMessage(`Installed: ${server.name} [${server.id}]`);
     } catch (err) {
       setMessage(`Install failed: ${err.message}`);
     } finally {
@@ -39877,7 +40300,7 @@ import { useState as useState6 } from "react";
 import { Box as Box6, Text as Text8 } from "ink";
 init_config2();
 import { jsxDEV as jsxDEV4 } from "react/jsx-dev-runtime";
-function ToolCall({ server: server2, tool, onBack }) {
+function ToolCall({ server, tool, onBack }) {
   const [argsInput, setArgsInput] = useState6("{}");
   const [calling, setCalling] = useState6(false);
   const [result, setResult] = useState6(null);
@@ -39894,8 +40317,8 @@ function ToolCall({ server: server2, tool, onBack }) {
     setError(null);
     setResult(null);
     try {
-      await connectToServer(server2);
-      const prefixed = `${server2.id}${TOOL_PREFIX_SEPARATOR}${tool.name}`;
+      await connectToServer(server);
+      const prefixed = `${server.id}${TOOL_PREFIX_SEPARATOR}${tool.name}`;
       const res = await callTool(prefixed, args);
       const text = res.content.map((c) => c.text).join(`
 `);
@@ -39923,9 +40346,9 @@ function ToolCall({ server: server2, tool, onBack }) {
         dimColor: true,
         children: [
           "Server: ",
-          server2.name,
+          server.name,
           " [",
-          server2.id,
+          server.id,
           "]"
         ]
       }, undefined, true, undefined, this),
@@ -40038,8 +40461,8 @@ function App() {
       }).finally(() => closeDb());
     };
   }, []);
-  const handleSelectServer = (server2) => {
-    setSelectedServer(server2);
+  const handleSelectServer = (server) => {
+    setSelectedServer(server);
     setView("detail");
   };
   const handleSearch = () => {
@@ -40107,13 +40530,31 @@ function App() {
 }
 
 // src/cli/index.tsx
-var VERSION2 = (() => {
+var VERSION3 = (() => {
   return readPackageVersion(import.meta.url);
 })();
 var MACHINE_PLATFORMS = ["linux", "darwin", "unknown"];
 var MACHINE_ARCHES = ["arm64", "x64", "unknown"];
 var MACHINE_INSTALLERS = ["auto", "bun", "npm"];
 var FLEET_INSTALL_MODES = ["missing", "missing-or-outdated", "all"];
+function printProviderProfile(profile) {
+  const status = profile.enabled ? chalk2.green("enabled") : chalk2.red("disabled");
+  console.log(`  ${chalk2.bold(profile.displayName)} ${chalk2.dim(`[${profile.id}]`)} \u2014 ${chalk2.dim(profile.transport)} \u2014 ${status}`);
+  if (profile.description)
+    console.log(`    ${chalk2.dim(profile.description)}`);
+  if (profile.endpoint)
+    console.log(`    ${chalk2.cyan(profile.endpoint)}`);
+  if (profile.authMetadata.bearerToken === "optional") {
+    console.log(`    ${chalk2.dim("Auth: OAuth with optional bearer token/API key support")}`);
+  } else if (profile.authMetadata.pkce || profile.authMetadata.dynamicClientRegistration) {
+    const parts = [
+      profile.authMetadata.oauthVersion ? `OAuth ${profile.authMetadata.oauthVersion}` : "OAuth",
+      profile.authMetadata.pkce ? "PKCE" : null,
+      profile.authMetadata.dynamicClientRegistration ? "dynamic client registration" : null
+    ].filter(Boolean);
+    console.log(`    ${chalk2.dim(`Auth: ${parts.join(", ")}`)}`);
+  }
+}
 function printJson(value) {
   console.log(JSON.stringify(value, null, 2));
 }
@@ -40212,7 +40653,7 @@ function renderFleetInstall(reports) {
   }
 }
 var program2 = new Command;
-program2.name("mcps").description("Meta-MCP registry & CLI \u2014 discover, manage, and proxy MCP servers").version(VERSION2).enablePositionalOptions();
+program2.name("mcps").description("Meta-MCP registry & CLI \u2014 discover, manage, and proxy MCP servers").version(VERSION3).enablePositionalOptions();
 program2.command("list").description("List registered MCP servers").option("--json", "Output as JSON").option("--verbose", "Show detailed info including health, command, and transport").action((opts) => {
   const servers = listServers();
   if (opts.json) {
@@ -40286,6 +40727,85 @@ ${results.length} result(s). Use \`mcps add --from-registry <id>\` to install.`)
     closeDb();
   }
 });
+var providersCmd = program2.command("providers").description("Discover and install curated MCP provider profiles");
+providersCmd.command("list").description("List curated provider profiles").option("--json", "Output as JSON").option("--enabled-only", "Only include enabled profiles").action((opts) => {
+  const profiles = listProviderProfiles({ enabledOnly: opts.enabledOnly === true });
+  if (opts.json) {
+    printJson(profiles);
+    closeDb();
+    return;
+  }
+  if (profiles.length === 0) {
+    console.log(chalk2.dim("No curated provider profiles available."));
+    closeDb();
+    return;
+  }
+  for (const profile of profiles)
+    printProviderProfile(profile);
+  closeDb();
+});
+providersCmd.command("search").argument("<query>", "Search query").description("Search curated provider profiles").option("--json", "Output as JSON").option("--enabled-only", "Only include enabled profiles").action((query, opts) => {
+  const profiles = searchProviderProfiles(query, { enabledOnly: opts.enabledOnly === true });
+  if (opts.json) {
+    printJson(profiles);
+    closeDb();
+    return;
+  }
+  if (profiles.length === 0) {
+    console.log(chalk2.dim("No curated provider profiles found."));
+    closeDb();
+    return;
+  }
+  for (const profile of profiles)
+    printProviderProfile(profile);
+  console.log(chalk2.dim(`
+${profiles.length} provider profile(s). Use \`mcps providers install <id>\` to register one.`));
+  closeDb();
+});
+providersCmd.command("info").argument("<id>", "Provider profile ID").description("Show a curated provider profile").option("--json", "Output as JSON").action((id, opts) => {
+  const profile = getProviderProfile(id);
+  if (!profile) {
+    console.error(chalk2.red(`Provider profile "${id}" not found.`));
+    closeDb();
+    process.exit(1);
+  }
+  if (opts.json) {
+    printJson(profile);
+    closeDb();
+    return;
+  }
+  printProviderProfile(profile);
+  if (profile.fallbackEndpoints.length > 0) {
+    console.log(chalk2.bold("    Fallback endpoints:"));
+    for (const fallback of profile.fallbackEndpoints) {
+      console.log(`      ${fallback.transport}: ${chalk2.cyan(fallback.url)}`);
+    }
+  }
+  if (profile.docsUrl)
+    console.log(`    Docs: ${chalk2.cyan(profile.docsUrl)}`);
+  closeDb();
+});
+providersCmd.command("install").argument("<id>", "Provider profile ID").description("Register a curated provider profile as an MCP server").option("--name <name>", "Override registered server name").option("--fallback", "Install the stdio fallback command instead of direct remote transport").option("--json", "Output as JSON").action((id, opts) => {
+  try {
+    const server = installProviderProfile(id, {
+      name: opts.name,
+      useFallback: opts.fallback === true
+    });
+    if (opts.json) {
+      printJson(server);
+    } else {
+      console.log(chalk2.green(`Installed provider profile: ${server.name} [${server.id}]`));
+      console.log(chalk2.dim(`  Transport: ${server.transport}`));
+      if (server.url)
+        console.log(chalk2.dim(`  URL: ${server.url}`));
+    }
+    closeDb();
+  } catch (err) {
+    console.error(chalk2.red(`Failed to install provider profile: ${err.message}`));
+    closeDb();
+    process.exit(1);
+  }
+});
 async function promptReadline(rl, question) {
   return new Promise((resolve2) => rl.question(question, resolve2));
 }
@@ -40304,9 +40824,9 @@ program2.command("add").passThroughOptions().argument("[command]", "Command to r
   try {
     if (opts.fromRegistry) {
       console.log(chalk2.dim(`Installing "${opts.fromRegistry}" from registry...`));
-      const server3 = await installFromRegistry(opts.fromRegistry);
-      console.log(chalk2.green(`Added server: ${server3.name} [${server3.id}]`));
-      console.log(chalk2.dim(`  ${server3.command} ${server3.args.join(" ")}`));
+      const server2 = await installFromRegistry(opts.fromRegistry);
+      console.log(chalk2.green(`Added server: ${server2.name} [${server2.id}]`));
+      console.log(chalk2.dim(`  ${server2.command} ${server2.args.join(" ")}`));
       closeDb();
       return;
     }
@@ -40355,7 +40875,7 @@ Server to add:`));
         closeDb();
         return;
       }
-      const server3 = addServer({
+      const server2 = addServer({
         command: wizardCommand,
         args: wizardArgs,
         name: wizardName || undefined,
@@ -40363,7 +40883,7 @@ Server to add:`));
         transport,
         env
       });
-      console.log(chalk2.green(`Added: ${server3.name} [${server3.id}]`));
+      console.log(chalk2.green(`Added: ${server2.name} [${server2.id}]`));
       closeDb();
       return;
     }
@@ -40391,7 +40911,7 @@ Server to add:`));
         envMap[key] = rest.join("=");
       }
     }
-    const server2 = addServer({
+    const server = addServer({
       name: opts.name,
       description: opts.description,
       command,
@@ -40400,8 +40920,8 @@ Server to add:`));
       url: opts.url,
       env: envMap
     });
-    console.log(chalk2.green(`Added server: ${server2.name} [${server2.id}]`));
-    console.log(chalk2.dim(`  ${server2.command} ${server2.args.join(" ")}`));
+    console.log(chalk2.green(`Added server: ${server.name} [${server.id}]`));
+    console.log(chalk2.dim(`  ${server.command} ${server.args.join(" ")}`));
   } catch (err) {
     if (err.message?.includes("UNIQUE constraint")) {
       console.error(chalk2.red("A server with that ID already exists."));
@@ -40414,8 +40934,8 @@ Server to add:`));
   closeDb();
 });
 program2.command("update-server").argument("<id>", "Server ID to update").description("Update fields of a registered server").option("--name <name>", "New display name").option("--description <desc>", "New description").option("--command <cmd>", "New command").option("--args <args...>", "New args list").option("--transport <type>", "New transport type").option("--url <url>", "New URL").action((id, opts) => {
-  const server2 = getServer(id);
-  if (!server2) {
+  const server = getServer(id);
+  if (!server) {
     console.error(chalk2.red(`Server "${id}" not found.`));
     closeDb();
     process.exit(1);
@@ -40450,53 +40970,53 @@ program2.command("clone").argument("<id>", "Server ID to clone").argument("<new-
   closeDb();
 });
 program2.command("remove").argument("<id>", "Server ID to remove").description("Remove a registered server").action((id) => {
-  const server2 = getServer(id);
-  if (!server2) {
+  const server = getServer(id);
+  if (!server) {
     console.error(chalk2.red(`Server "${id}" not found.`));
     closeDb();
     process.exit(1);
   }
   removeServer(id);
-  console.log(chalk2.green(`Removed server: ${server2.name} [${id}]`));
+  console.log(chalk2.green(`Removed server: ${server.name} [${id}]`));
   closeDb();
 });
 program2.command("enable").argument("<id>", "Server ID to enable").description("Enable a server").action((id) => {
-  const server2 = getServer(id);
-  if (!server2) {
+  const server = getServer(id);
+  if (!server) {
     console.error(chalk2.red(`Server "${id}" not found.`));
     closeDb();
     process.exit(1);
   }
   enableServer(id);
-  console.log(chalk2.green(`Enabled server: ${server2.name}`));
+  console.log(chalk2.green(`Enabled server: ${server.name}`));
   closeDb();
 });
 program2.command("disable").argument("<id>", "Server ID to disable").description("Disable a server").action((id) => {
-  const server2 = getServer(id);
-  if (!server2) {
+  const server = getServer(id);
+  if (!server) {
     console.error(chalk2.red(`Server "${id}" not found.`));
     closeDb();
     process.exit(1);
   }
   disableServer(id);
-  console.log(chalk2.yellow(`Disabled server: ${server2.name}`));
+  console.log(chalk2.yellow(`Disabled server: ${server.name}`));
   closeDb();
 });
 program2.command("tools").argument("[server-id]", "Optional server ID to filter by").description("List tools (all or per server)").option("--connect", "Connect to servers to fetch live tools").action(async (serverId, opts) => {
   if (opts.connect) {
     console.log(chalk2.dim("Connecting to enabled servers..."));
     await connectAllEnabled();
-    const tools = listAllTools();
-    if (tools.length === 0) {
+    const tools2 = listAllTools();
+    if (tools2.length === 0) {
       console.log(chalk2.dim("No tools available."));
     } else {
-      for (const t of tools) {
+      for (const t of tools2) {
         console.log(`  ${chalk2.bold(t.name)}`);
         if (t.description)
           console.log(`    ${chalk2.dim(t.description)}`);
       }
       console.log(chalk2.dim(`
-${tools.length} tool(s) available.`));
+${tools2.length} tool(s) available.`));
     }
     await disconnectAll();
   } else if (serverId) {
@@ -40576,26 +41096,26 @@ program2.command("call").argument("<tool>", "Tool name (server_id__tool_name)").
     process.exit(exitCode);
 });
 program2.command("info").argument("<id>", "Server ID").description("Show server details & tools").action((id) => {
-  const server2 = getServer(id);
-  if (!server2) {
+  const server = getServer(id);
+  if (!server) {
     console.error(chalk2.red(`Server "${id}" not found.`));
     closeDb();
     process.exit(1);
   }
-  console.log(chalk2.bold(server2.name) + " " + chalk2.dim(`[${server2.id}]`));
-  console.log(`  Status:    ${server2.enabled ? chalk2.green("enabled") : chalk2.red("disabled")}`);
-  console.log(`  Source:    ${server2.source}`);
-  console.log(`  Transport: ${server2.transport}`);
-  console.log(`  Command:   ${server2.command} ${server2.args.join(" ")}`);
-  if (server2.url)
-    console.log(`  URL:       ${server2.url}`);
-  if (server2.description)
-    console.log(`  Desc:      ${server2.description}`);
-  if (Object.keys(server2.env).length > 0) {
-    console.log(`  Env:       ${Object.entries(server2.env).map(([k, v]) => `${k}=${v}`).join(", ")}`);
-  }
-  console.log(`  Created:   ${server2.created_at}`);
-  console.log(`  Updated:   ${server2.updated_at}`);
+  console.log(chalk2.bold(server.name) + " " + chalk2.dim(`[${server.id}]`));
+  console.log(`  Status:    ${server.enabled ? chalk2.green("enabled") : chalk2.red("disabled")}`);
+  console.log(`  Source:    ${server.source}`);
+  console.log(`  Transport: ${server.transport}`);
+  console.log(`  Command:   ${server.command} ${server.args.join(" ")}`);
+  if (server.url)
+    console.log(`  URL:       ${server.url}`);
+  if (server.description)
+    console.log(`  Desc:      ${server.description}`);
+  if (Object.keys(server.env).length > 0) {
+    console.log(`  Env:       ${Object.entries(server.env).map(([k, v]) => `${k}=${v}`).join(", ")}`);
+  }
+  console.log(`  Created:   ${server.created_at}`);
+  console.log(`  Updated:   ${server.updated_at}`);
   const cached2 = getCachedTools(id);
   if (cached2.length > 0) {
     console.log(chalk2.bold(`
@@ -40635,10 +41155,10 @@ program2.command("doctor").argument("[id]", "Server ID to check (omit to check a
     return;
   }
   let allHealthy = true;
-  for (const server2 of servers) {
+  for (const server of servers) {
     console.log(chalk2.bold(`
-${server2.name} [${server2.id}]`));
-    const report = await diagnoseServer(server2);
+${server.name} [${server.id}]`));
+    const report = await diagnoseServer(server);
     for (const check2 of report.checks) {
       const icon = check2.pass ? chalk2.green("\u2713") : chalk2.red("\u2717");
       console.log(`  ${icon} ${check2.name}: ${chalk2.dim(check2.message)}`);
@@ -40664,7 +41184,7 @@ ${server2.name} [${server2.id}]`));
   closeDb();
 });
 program2.command("completion").argument("<shell>", "Shell type: bash, zsh, fish").description("Generate shell completion script").action((shell) => {
-  const commands = ["list", "search", "find", "add", "remove", "enable", "disable", "info", "status", "tools", "call", "doctor", "install", "machines", "fleet", "export", "import", "env", "sources", "clone", "update-server", "serve", "update", "mcp", "completion"];
+  const commands = ["list", "search", "providers", "find", "add", "remove", "enable", "disable", "info", "status", "tools", "call", "doctor", "install", "machines", "fleet", "export", "import", "env", "sources", "clone", "update-server", "serve", "update", "mcp", "completion"];
   if (shell === "bash") {
     console.log(`# Add to ~/.bashrc: eval "$(mcps completion bash)"
 _mcps_complete() {
@@ -40834,14 +41354,14 @@ Enter number to install (1-${results.length}), or 0 to cancel: `), resolve2);
         return;
       }
       console.log(chalk2.dim(`Installing ${chosen.name}...`));
-      const server2 = addServer({
+      const server = addServer({
         command: "npx",
         args: ["-y", pkg],
         name: chosen.name,
         description: chosen.description,
         transport: "stdio"
       });
-      const results2 = installToAgents(server2, ["claude", "codex", "gemini"]);
+      const results2 = installToAgents(server, ["claude", "codex", "gemini"]);
       for (const r of results2) {
         if (r.success) {
           console.log(chalk2.green(`  \u2713 ${r.agent}`));
@@ -40850,7 +41370,7 @@ Enter number to install (1-${results.length}), or 0 to cancel: `), resolve2);
         }
       }
       console.log(chalk2.green(`
-Installed ${server2.name} [${server2.id}]`));
+Installed ${server.name} [${server.id}]`));
     }
   } catch (err) {
     console.error(chalk2.red(`Find failed: ${err.message}`));
@@ -41008,12 +41528,12 @@ program2.command("install").argument("[id]", "Server ID (from `mcps list`) to in
     if (!targets.includes("gemini"))
       targets.push("gemini");
   }
-  let server2;
+  let server;
   if (opts.fromRegistry) {
     console.log(chalk2.dim(`Installing "${opts.fromRegistry}" from registry...`));
     try {
-      server2 = await installFromRegistry(opts.fromRegistry);
-      console.log(chalk2.green(`Added server: ${server2.name} [${server2.id}]`));
+      server = await installFromRegistry(opts.fromRegistry);
+      console.log(chalk2.green(`Added server: ${server.name} [${server.id}]`));
     } catch (err) {
       console.error(chalk2.red(`Failed to install from registry: ${err.message}`));
       closeDb();
@@ -41021,23 +41541,23 @@ program2.command("install").argument("[id]", "Server ID (from `mcps list`) to in
     }
   } else if (opts.npm) {
     const pkg = opts.npm;
-    server2 = addServer({ command: "npx", args: ["-y", pkg], name: pkg, transport: "stdio" });
-    console.log(chalk2.green(`Added server: ${server2.name} [${server2.id}]`));
+    server = addServer({ command: "npx", args: ["-y", pkg], name: pkg, transport: "stdio" });
+    console.log(chalk2.green(`Added server: ${server.name} [${server.id}]`));
   } else {
     if (!id) {
       console.error(chalk2.red("Error: server ID is required (or use --from-registry or --npm)"));
       closeDb();
       process.exit(1);
     }
-    server2 = getServer(id);
-    if (!server2) {
+    server = getServer(id);
+    if (!server) {
       console.error(chalk2.red(`Server "${id}" not found. Use \`mcps add\` first.`));
       closeDb();
       process.exit(1);
     }
   }
-  console.log(chalk2.dim(`Installing "${server2.name}" to: ${targets.join(", ")}...`));
-  const results = installToAgents(server2, targets);
+  console.log(chalk2.dim(`Installing "${server.name}" to: ${targets.join(", ")}...`));
+  const results = installToAgents(server, targets);
   for (const r of results) {
     if (r.success) {
       console.log(chalk2.green(`  \u2713 ${r.agent}`));
@@ -41280,13 +41800,13 @@ program2.command("import").argument("<file>", "Path to the export JSON file").de
 });
 var envCmd = program2.command("env").description("Manage server environment variables");
 envCmd.command("list").argument("<id>").description("List env vars for a server").action((id) => {
-  const server2 = getServer(id);
-  if (!server2) {
+  const server = getServer(id);
+  if (!server) {
     console.error(chalk2.red(`Server "${id}" not found.`));
     closeDb();
     process.exit(1);
   }
-  const entries = Object.entries(server2.env);
+  const entries = Object.entries(server.env);
   if (entries.length === 0) {
     console.log(chalk2.dim("No env vars set."));
     closeDb();
@@ -41331,7 +41851,7 @@ program2.command("mcp").description("Start meta-MCP server (stdio)").action(asyn
 });
 program2.command("feedback <message>").description("Send feedback").option("--email <email>", "Contact email").option("--category <category>", "Category: bug, feature, general").action((message, opts) => {
   const adapter = getAdapter();
-  adapter.run("INSERT INTO feedback (message, email, category, version) VALUES (?, ?, ?, ?)", message, opts.email || null, opts.category || "general", VERSION2);
+  adapter.run("INSERT INTO feedback (message, email, category, version) VALUES (?, ?, ?, ?)", message, opts.email || null, opts.category || "general", VERSION3);
   console.log(chalk2.green("Feedback saved. Thank you!"));
   closeDb();
 });