@hasna/mcps 0.0.11 → 0.0.13

package/bin/index.js

@@ -19288,15 +19288,23 @@ var init_sources = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@hasna/mcps",
-    version: "0.0.11",
+    version: "0.0.13",
     description: "Meta-MCP registry & CLI \u2014 discover, manage, and proxy MCP servers",
     type: "module",
+    repository: {
+      type: "git",
+      url: "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 +19319,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",
@@ -21011,8 +21019,6 @@ import React10 from "react";
 import { render } from "ink";
 import chalk2 from "chalk";
 import { readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
-import { join as join12, dirname as dirname5 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/lib/registry.ts
 init_db();
@@ -36764,6 +36770,68 @@ async function runFleetInstall(options = {}, dependencies = {}) {
 // 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) {
@@ -37925,535 +37993,634 @@ 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/lib/version.ts
+import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname3, join as join10 } from "path";
+import { fileURLToPath } from "url";
+var FALLBACK_VERSION = "0.0.1";
+function readPackageVersion(moduleUrl, fallback = FALLBACK_VERSION) {
+  const baseDir = dirname3(fileURLToPath(moduleUrl));
+  const candidates = [
+    join10(baseDir, "..", "..", "package.json"),
+    join10(baseDir, "..", "package.json"),
+    join10(baseDir, "package.json")
+  ];
+  for (const candidate of candidates) {
+    if (!existsSync9(candidate))
+      continue;
+    try {
+      const pkg = JSON.parse(readFileSync5(candidate, "utf-8"));
+      if (pkg.version)
+        return pkg.version;
+    } catch {}
   }
+  return fallback;
 }
 
-// src/mcp/index.ts
-init_dist();
-import { readFileSync as readFileSync5 } from "fs";
-import { join as join10, dirname as dirname3 } from "path";
-import { fileURLToPath } from "url";
+// 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 = (() => {
-  try {
-    const pkgPath = join10(dirname3(fileURLToPath(import.meta.url)), "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
-    return pkg.version || "0.0.1";
-  } catch {
-    return "0.0.1";
-  }
-})();
-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
-    };
+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_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)));
   }
-  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
-    };
+  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);
   }
-  const entry = disableServer(id);
   return {
-    content: [{ type: "text", text: JSON.stringify(entry, null, 2) }]
+    type: "object",
+    properties,
+    ...required2.length > 0 ? { required: required2 } : {},
+    additionalProperties: false
   };
-});
-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
-    };
+}
+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 };
   }
-  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) }]
-    };
+  if (typeName === exports_external2.ZodFirstPartyTypeKind.ZodNullable) {
+    return { ...asJsonSchemaObject(zodSchemaToJsonSchema(def.innerType)), nullable: true, ...description };
   }
-  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 });
-    }
+  if (typeName === exports_external2.ZodFirstPartyTypeKind.ZodString) {
+    return { type: "string", ...description };
   }
-  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
-    };
+  if (typeName === exports_external2.ZodFirstPartyTypeKind.ZodBoolean) {
+    return { type: "boolean", ...description };
   }
-  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
-    };
+  if (typeName === exports_external2.ZodFirstPartyTypeKind.ZodUnknown || typeName === exports_external2.ZodFirstPartyTypeKind.ZodAny) {
+    return Object.keys(description).length > 0 ? description : true;
   }
-  removeSource(id);
-  return {
-    content: [{ type: "text", text: `Removed source: ${existing.name} [${id}]` }]
-  };
-});
-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
+  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;
   }
-  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.ZodEnum) {
+    return { type: "string", enum: def.values, ...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.ZodArray) {
+    return { type: "array", items: zodSchemaToJsonSchema(def.type), ...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.ZodRecord) {
+    const valueType = def.valueType ? zodSchemaToJsonSchema(def.valueType) : true;
+    return { type: "object", additionalProperties: valueType, ...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.ZodObject) {
+    const objectShape = typeof def.shape === "function" ? def.shape() : def.shape;
+    return { ...zodRawShapeToJsonSchema(objectShape ?? {}), ...description };
   }
-});
-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 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(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
-    };
+  registerMcpTools(server, options.tools);
+  if (options.cloudTools !== false) {
+    registerCloudTools(server, "mcps");
   }
-  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
-  });
-  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()]) }] };
-});
+  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");
@@ -38465,13 +38632,13 @@ if (isDirectRun) {
 }
 
 // src/server/serve.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { join as join11, dirname as dirname4, extname, resolve, relative as relative2, sep } from "path";
 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 = [];
@@ -38487,7 +38654,7 @@ function resolveDashboardDir() {
   }
   candidates.push(join11(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
-    if (existsSync9(candidate))
+    if (existsSync10(candidate))
       return candidate;
   }
   return join11(process.cwd(), "dashboard", "dist");
@@ -38578,7 +38745,7 @@ function getAllServersWithToolCount() {
   }));
 }
 function serveStaticFile(filePath) {
-  if (!existsSync9(filePath))
+  if (!existsSync10(filePath))
     return null;
   const ext = extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
@@ -38611,7 +38778,7 @@ async function startServer(port, options) {
   const host = options?.host ?? "127.0.0.1";
   getDb();
   const dashboardDir = resolveDashboardDir();
-  const dashboardExists = existsSync9(dashboardDir);
+  const dashboardExists = existsSync10(dashboardDir);
   if (!dashboardExists) {
     console.error(`
 Dashboard not found at: ${dashboardDir}`);
@@ -38620,7 +38787,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) {
@@ -38691,8 +38858,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];
@@ -38820,8 +38987,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") {
@@ -39004,7 +39171,7 @@ Dashboard not found at: ${dashboardDir}`);
     }
   });
   const shutdown = () => {
-    server2.stop();
+    server.stop();
     closeDb();
     process.exit(0);
   };
@@ -39517,18 +39684,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
@@ -39536,12 +39703,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);
@@ -39550,8 +39717,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
@@ -39560,7 +39727,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();
@@ -39573,36 +39740,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,
@@ -39624,7 +39791,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,
@@ -39768,8 +39935,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 {
@@ -39862,7 +40029,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);
@@ -39879,8 +40046,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(`
 `);
@@ -39908,9 +40075,9 @@ function ToolCall({ server: server2, tool, onBack }) {
         dimColor: true,
         children: [
           "Server: ",
-          server2.name,
+          server.name,
           " [",
-          server2.id,
+          server.id,
           "]"
         ]
       }, undefined, true, undefined, this),
@@ -40023,8 +40190,8 @@ function App() {
       }).finally(() => closeDb());
     };
   }, []);
-  const handleSelectServer = (server2) => {
-    setSelectedServer(server2);
+  const handleSelectServer = (server) => {
+    setSelectedServer(server);
     setView("detail");
   };
   const handleSearch = () => {
@@ -40092,14 +40259,8 @@ function App() {
 }
 
 // src/cli/index.tsx
-var VERSION2 = (() => {
-  try {
-    const pkgPath = join12(dirname5(fileURLToPath3(import.meta.url)), "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
-    return pkg.version || "0.0.1";
-  } catch {
-    return "0.0.1";
-  }
+var VERSION3 = (() => {
+  return readPackageVersion(import.meta.url);
 })();
 var MACHINE_PLATFORMS = ["linux", "darwin", "unknown"];
 var MACHINE_ARCHES = ["arm64", "x64", "unknown"];
@@ -40203,7 +40364,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) {
@@ -40295,9 +40456,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;
     }
@@ -40346,7 +40507,7 @@ Server to add:`));
         closeDb();
         return;
       }
-      const server3 = addServer({
+      const server2 = addServer({
         command: wizardCommand,
         args: wizardArgs,
         name: wizardName || undefined,
@@ -40354,7 +40515,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;
     }
@@ -40382,7 +40543,7 @@ Server to add:`));
         envMap[key] = rest.join("=");
       }
     }
-    const server2 = addServer({
+    const server = addServer({
       name: opts.name,
       description: opts.description,
       command,
@@ -40391,8 +40552,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."));
@@ -40405,8 +40566,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);
@@ -40441,53 +40602,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) {
@@ -40567,26 +40728,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(`
@@ -40626,10 +40787,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)}`);
@@ -40825,14 +40986,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}`));
@@ -40841,7 +41002,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}`));
@@ -40999,12 +41160,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();
@@ -41012,23 +41173,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}`));
@@ -41271,13 +41432,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();
@@ -41322,7 +41483,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();
 });