@justanothermldude/mcp-exec 1.1.0 → 1.2.0

package/dist/index.js

@@ -1,67 +1,1475 @@
-#!/usr/bin/env node
-/**
- * @meta-mcp/exec - MCP execution utilities for sandboxed code execution
- *
- * Entry point for both the MCP server and programmatic API usage.
- */
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { createMcpExecServer } from './server.js';
-import { ServerPool, createConnection, getServerConfig, loadServerManifest } from '@justanothermldude/meta-mcp-core';
-// Export types
-export * from './types/index.js';
-// Export sandbox module
-export * from './sandbox/index.js';
-// Export codegen module
-export * from './codegen/index.js';
-// Export bridge module
-export * from './bridge/index.js';
-// Export tools module
-export * from './tools/index.js';
-// Export server module
-export { createMcpExecServer } from './server.js';
-import { SandboxExecutor } from './sandbox/index.js';
-import { DEFAULT_TIMEOUT_MS } from './types/execution.js';
-export const APP_NAME = 'mcp-exec';
-export const VERSION = '0.1.0';
-// Default executor instance (lazily initialized)
-let defaultExecutor = null;
-/**
- * Get or create the default SandboxExecutor instance
- */
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// dist/index.js
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// dist/server.js
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// dist/tools/list-servers.js
+import { listServers } from "@justanothermldude/meta-mcp-core";
+var listAvailableMcpServersTool = {
+  name: "list_available_mcp_servers",
+  description: "List available MCP servers with their names, descriptions, and tags. Optionally filter by name or tag.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      filter: {
+        type: "string",
+        description: "Optional filter string to match server names, descriptions, or tags"
+      }
+    },
+    required: []
+  }
+};
+function createListServersHandler() {
+  return /* @__PURE__ */ __name(async function listServersHandler(args2) {
+    const { filter } = args2;
+    try {
+      let servers = listServers();
+      if (filter && typeof filter === "string") {
+        const filterLower = filter.toLowerCase();
+        servers = servers.filter((server) => {
+          if (server.name.toLowerCase().includes(filterLower)) {
+            return true;
+          }
+          if (server.description?.toLowerCase().includes(filterLower)) {
+            return true;
+          }
+          if (server.tags?.some((tag) => tag.toLowerCase().includes(filterLower))) {
+            return true;
+          }
+          return false;
+        });
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(servers, null, 2) }],
+        isError: false
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "text", text: `Error listing servers: ${errorMessage}` }],
+        isError: true
+      };
+    }
+  }, "listServersHandler");
+}
+__name(createListServersHandler, "createListServersHandler");
+function isListServersInput(args2) {
+  if (typeof args2 !== "object" || args2 === null) {
+    return false;
+  }
+  const input = args2;
+  if ("filter" in input && typeof input.filter !== "string") {
+    return false;
+  }
+  return true;
+}
+__name(isListServersInput, "isListServersInput");
+
+// dist/tools/get-tool-schema.js
+var getMcpToolSchemaTool = {
+  name: "get_mcp_tool_schema",
+  description: "Get the full schema for a specific MCP tool, or list all tools on a server. Omit tool param to discover available tools.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      server: {
+        type: "string",
+        description: "The name of the MCP server that has the tool"
+      },
+      tool: {
+        type: "string",
+        description: "The name of the tool to get the schema for. Omit to list all tools."
+      }
+    },
+    required: ["server"]
+  }
+};
+function createGetToolSchemaHandler(pool) {
+  return /* @__PURE__ */ __name(async function getToolSchemaHandler(args2) {
+    const { server, tool } = args2;
+    try {
+      const connection = await pool.getConnection(server);
+      const tools = await connection.getTools();
+      if (!tool) {
+        const summary = tools.map((t) => ({
+          name: t.name,
+          description: t.description || ""
+        }));
+        return {
+          content: [{ type: "text", text: JSON.stringify(summary, null, 2) }],
+          isError: false
+        };
+      }
+      const matchedTool = tools.find((t) => t.name === tool);
+      if (!matchedTool) {
+        const availableTools = tools.map((t) => t.name).sort();
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Tool '${tool}' not found on server '${server}'. Available tools: ${availableTools.join(", ")}`
+            }
+          ],
+          isError: true
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(matchedTool, null, 2) }],
+        isError: false
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("not found") || errorMessage.includes("unknown server")) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error connecting to server '${server}': ${errorMessage}. Use list_available_mcp_servers to see available servers.`
+            }
+          ],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error getting tool schema: ${errorMessage}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }, "getToolSchemaHandler");
+}
+__name(createGetToolSchemaHandler, "createGetToolSchemaHandler");
+function isGetToolSchemaInput(args2) {
+  if (typeof args2 !== "object" || args2 === null) {
+    return false;
+  }
+  const input = args2;
+  if (typeof input.server !== "string") {
+    return false;
+  }
+  if (input.tool !== void 0 && typeof input.tool !== "string") {
+    return false;
+  }
+  return true;
+}
+__name(isGetToolSchemaInput, "isGetToolSchemaInput");
+
+// dist/codegen/wrapper-generator.js
+var BRIDGE_ENDPOINT = "http://127.0.0.1:3000/call";
+function jsonSchemaToTs(prop, _required = true) {
+  if (!prop) {
+    return "unknown";
+  }
+  if (Array.isArray(prop.type)) {
+    const types = prop.type.map((t) => primitiveToTs(t));
+    return types.join(" | ");
+  }
+  if (prop.enum) {
+    return prop.enum.map((v) => JSON.stringify(v)).join(" | ");
+  }
+  if (prop.type === "object" && prop.properties) {
+    const propLines = Object.entries(prop.properties).map(([key, value]) => {
+      const isRequired = prop.required?.includes(key) ?? false;
+      const tsType = jsonSchemaToTs(value, isRequired);
+      const optionalMark = isRequired ? "" : "?";
+      return `${key}${optionalMark}: ${tsType}`;
+    });
+    return `{ ${propLines.join("; ")} }`;
+  }
+  if (prop.type === "array") {
+    const itemType = prop.items ? jsonSchemaToTs(prop.items, true) : "unknown";
+    return `${itemType}[]`;
+  }
+  return primitiveToTs(prop.type ?? "unknown");
+}
+__name(jsonSchemaToTs, "jsonSchemaToTs");
+function primitiveToTs(type) {
+  switch (type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "object":
+      return "Record<string, unknown>";
+    case "array":
+      return "unknown[]";
+    default:
+      return "unknown";
+  }
+}
+__name(primitiveToTs, "primitiveToTs");
+function generateInterface(name, schema) {
+  if (!schema.properties || Object.keys(schema.properties).length === 0) {
+    return `interface ${name} {}`;
+  }
+  const lines = [];
+  lines.push(`interface ${name} {`);
+  for (const [propName, propValue] of Object.entries(schema.properties)) {
+    const prop = propValue;
+    const isRequired = schema.required?.includes(propName) ?? false;
+    const optionalMark = isRequired ? "" : "?";
+    const tsType = jsonSchemaToTs(prop, isRequired);
+    if (prop.description) {
+      lines.push(`  /** ${prop.description} */`);
+    }
+    lines.push(`  ${propName}${optionalMark}: ${tsType};`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+__name(generateInterface, "generateInterface");
+function sanitizeIdentifier(name) {
+  let sanitized = name.replace(/[^a-zA-Z0-9_]/g, "_");
+  if (/^[0-9]/.test(sanitized)) {
+    sanitized = "_" + sanitized;
+  }
+  return sanitized;
+}
+__name(sanitizeIdentifier, "sanitizeIdentifier");
+function normalizeName(name) {
+  return name.toLowerCase().replace(/[_-]/g, "");
+}
+__name(normalizeName, "normalizeName");
+function generateFuzzyProxy(targetVarName, contextName) {
+  const safeContextName = JSON.stringify(contextName);
+  return `new Proxy(${targetVarName}, {
+  get(target, prop) {
+    if (typeof prop !== 'string') return undefined;
+
+    // Fast-path: exact match
+    if (prop in target) return target[prop];
+
+    // Fuzzy match: normalize and search
+    const normalizedProp = prop.toLowerCase().replace(/[_-]/g, '');
+    for (const key of Object.keys(target)) {
+      const normalizedKey = key.toLowerCase().replace(/[_-]/g, '');
+      if (normalizedKey === normalizedProp) {
+        return target[key];
+      }
+    }
+
+    // No match found - throw helpful error
+    const available = Object.keys(target).join(', ');
+    throw new TypeError(\`Property "\${prop}" not found on ${safeContextName}. Available: \${available}\`);
+  }
+})`;
+}
+__name(generateFuzzyProxy, "generateFuzzyProxy");
+function toPascalCase(name) {
+  return name.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+__name(toPascalCase, "toPascalCase");
+function generateToolInterface(tool) {
+  const interfaceName = `${toPascalCase(tool.name)}Input`;
+  if (tool.inputSchema?.properties && Object.keys(tool.inputSchema.properties).length > 0) {
+    return generateInterface(interfaceName, tool.inputSchema);
+  }
+  return "";
+}
+__name(generateToolInterface, "generateToolInterface");
+function generateMethodDefinition(tool, serverName, bridgePort) {
+  const methodName = sanitizeIdentifier(tool.name);
+  const interfaceName = `${toPascalCase(tool.name)}Input`;
+  const hasInput = tool.inputSchema?.properties && Object.keys(tool.inputSchema.properties).length > 0;
+  const inputParam = hasInput ? `input: ${interfaceName}` : "";
+  const inputArg = hasInput ? "input" : "{}";
+  const lines = [];
+  if (tool.description) {
+    lines.push("  /**");
+    lines.push(`   * ${tool.description}`);
+    if (tool.inputSchema?.properties) {
+      for (const [propName, propValue] of Object.entries(tool.inputSchema.properties)) {
+        const prop = propValue;
+        if (prop.description) {
+          lines.push(`   * @param input.${propName} - ${prop.description}`);
+        }
+      }
+    }
+    lines.push("   */");
+  }
+  const safeServerName = JSON.stringify(serverName);
+  const safeToolName = JSON.stringify(tool.name);
+  lines.push(`  ${methodName}: async (${inputParam}): Promise<unknown> => {`);
+  lines.push(`    const response = await fetch('http://127.0.0.1:${bridgePort}/call', {`);
+  lines.push(`      method: 'POST',`);
+  lines.push(`      headers: { 'Content-Type': 'application/json' },`);
+  lines.push(`      body: JSON.stringify({`);
+  lines.push(`        server: ${safeServerName},`);
+  lines.push(`        tool: ${safeToolName},`);
+  lines.push(`        args: ${inputArg},`);
+  lines.push(`      }),`);
+  lines.push(`    });`);
+  lines.push(`    if (!response.ok) {`);
+  lines.push("      throw new Error(`Tool call failed: ${response.statusText}`);");
+  lines.push(`    }`);
+  lines.push(`    const data = await response.json() as { success: boolean; content?: unknown; error?: string };`);
+  lines.push(`    if (!data.success) {`);
+  lines.push(`      throw new Error(data.error || 'Tool call failed');`);
+  lines.push(`    }`);
+  lines.push(`    // Auto-parse JSON from MCP text content blocks for convenience`);
+  lines.push(`    const content = data.content;`);
+  lines.push(`    if (Array.isArray(content) && content.length === 1 && content[0]?.type === 'text') {`);
+  lines.push(`      try {`);
+  lines.push(`        return JSON.parse(content[0].text);`);
+  lines.push(`      } catch {`);
+  lines.push(`        return content[0].text;`);
+  lines.push(`      }`);
+  lines.push(`    }`);
+  lines.push(`    return content;`);
+  lines.push(`  },`);
+  return lines.join("\n");
+}
+__name(generateMethodDefinition, "generateMethodDefinition");
+function generateToolWrapper(tool, serverName) {
+  const funcName = sanitizeIdentifier(tool.name);
+  const interfaceName = `${toPascalCase(tool.name)}Input`;
+  const lines = [];
+  if (tool.inputSchema?.properties && Object.keys(tool.inputSchema.properties).length > 0) {
+    lines.push(generateInterface(interfaceName, tool.inputSchema));
+    lines.push("");
+  }
+  if (tool.description) {
+    lines.push("/**");
+    lines.push(` * ${tool.description}`);
+    if (tool.inputSchema?.properties) {
+      lines.push(" *");
+      for (const [propName, propValue] of Object.entries(tool.inputSchema.properties)) {
+        const prop = propValue;
+        if (prop.description) {
+          lines.push(` * @param input.${propName} - ${prop.description}`);
+        }
+      }
+    }
+    lines.push(" * @returns Promise resolving to tool result");
+    lines.push(" */");
+  }
+  const hasInput = tool.inputSchema?.properties && Object.keys(tool.inputSchema.properties).length > 0;
+  const inputParam = hasInput ? `input: ${interfaceName}` : "";
+  const inputArg = hasInput ? "input" : "{}";
+  lines.push(`async function ${funcName}(${inputParam}): Promise<unknown> {`);
+  lines.push(`  const response = await fetch('${BRIDGE_ENDPOINT}', {`);
+  lines.push(`    method: 'POST',`);
+  lines.push(`    headers: { 'Content-Type': 'application/json' },`);
+  lines.push(`    body: JSON.stringify({`);
+  lines.push(`      server: '${serverName}',`);
+  lines.push(`      tool: '${tool.name}',`);
+  lines.push(`      args: ${inputArg},`);
+  lines.push(`    }),`);
+  lines.push(`  });`);
+  lines.push("");
+  lines.push("  if (!response.ok) {");
+  lines.push("    throw new Error(`Tool call failed: ${response.statusText}`);");
+  lines.push("  }");
+  lines.push("");
+  lines.push("  return response.json();");
+  lines.push("}");
+  return lines.join("\n");
+}
+__name(generateToolWrapper, "generateToolWrapper");
+function generateServerModule(tools, serverName, bridgePort = 3e3) {
+  const lines = [];
+  const namespaceName = sanitizeIdentifier(serverName);
+  lines.push("/**");
+  lines.push(` * Auto-generated TypeScript wrappers for ${serverName} MCP server tools.`);
+  lines.push(` * Case-insensitive: methodName, method_name, and method-name all work.`);
+  lines.push(` * Access tools via: ${namespaceName}.methodName()`);
+  lines.push(" */");
+  lines.push("");
+  for (const tool of tools) {
+    const interfaceCode = generateToolInterface(tool);
+    if (interfaceCode) {
+      lines.push(interfaceCode);
+      lines.push("");
+    }
+  }
+  lines.push(`const ${namespaceName}_raw = {`);
+  for (let i = 0; i < tools.length; i++) {
+    const tool = tools[i];
+    lines.push(generateMethodDefinition(tool, serverName, bridgePort));
+  }
+  lines.push("};");
+  lines.push("");
+  lines.push(`const ${namespaceName} = ${generateFuzzyProxy(`${namespaceName}_raw`, serverName)};`);
+  lines.push("");
+  return lines.join("\n");
+}
+__name(generateServerModule, "generateServerModule");
+function generateMcpDictionary(serverNames) {
+  const lines = [];
+  const sanitizedNames = serverNames.map(sanitizeIdentifier);
+  lines.push("/**");
+  lines.push(" * MCP Server Dictionary - Access all MCP servers via case-agnostic lookup.");
+  lines.push(` * Available: ${serverNames.map((n) => `mcp['${n}']`).join(", ")}`);
+  lines.push(` * Aliases: ${sanitizedNames.join(", ")}`);
+  lines.push(" */");
+  lines.push("");
+  lines.push("const mcp_servers_raw: Record<string, unknown> = {");
+  for (const serverName of serverNames) {
+    const sanitized = sanitizeIdentifier(serverName);
+    lines.push(`  ${JSON.stringify(serverName)}: ${sanitized},`);
+  }
+  lines.push("};");
+  lines.push("");
+  lines.push(`const mcp = ${generateFuzzyProxy("mcp_servers_raw", "mcp")};`);
+  lines.push("");
+  return lines.join("\n");
+}
+__name(generateMcpDictionary, "generateMcpDictionary");
+
+// dist/codegen/module-resolver.js
+import { loadServerManifest } from "@justanothermldude/meta-mcp-core";
+function sanitizeFileName(name) {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_").toLowerCase();
+}
+__name(sanitizeFileName, "sanitizeFileName");
+var VirtualModuleResolver = class {
+  static {
+    __name(this, "VirtualModuleResolver");
+  }
+  constructor() {
+    this.modules = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a virtual module at the given path
+   * @param path - Virtual path (e.g., ./servers/github/create_issue.ts)
+   * @param code - Generated TypeScript code
+   */
+  registerModule(path, code) {
+    this.modules.set(this.normalizePath(path), code);
+  }
+  /**
+   * Resolve a virtual module path to its generated code
+   * @param path - Virtual path to resolve
+   * @returns Generated TypeScript code or undefined if not found
+   */
+  resolve(path) {
+    return this.modules.get(this.normalizePath(path));
+  }
+  /**
+   * Check if a virtual module exists at the given path
+   * @param path - Virtual path to check
+   * @returns True if module exists
+   */
+  has(path) {
+    return this.modules.has(this.normalizePath(path));
+  }
+  /**
+   * Clear all registered modules
+   */
+  clear() {
+    this.modules.clear();
+  }
+  /**
+   * Get the number of registered modules
+   */
+  size() {
+    return this.modules.size;
+  }
+  /**
+   * Get all registered module paths
+   */
+  listModules() {
+    return Array.from(this.modules.keys());
+  }
+  /**
+   * Normalize a path for consistent lookup
+   */
+  normalizePath(path) {
+    return path.replace(/^\.\//, "").replace(/\\/g, "/");
+  }
+  /**
+   * Generate the virtual path for a tool
+   * @param serverName - Name of the MCP server
+   * @param toolName - Name of the tool
+   * @returns Virtual path in format servers/<name>/<tool>.ts
+   */
+  static getToolPath(serverName, toolName) {
+    return `servers/${serverName}/${sanitizeFileName(toolName)}.ts`;
+  }
+  /**
+   * Generate the virtual path for a server's index module
+   * @param serverName - Name of the MCP server
+   * @returns Virtual path in format servers/<name>/index.ts
+   */
+  static getServerIndexPath(serverName) {
+    return `servers/${serverName}/index.ts`;
+  }
+};
+async function generateFromManifest(resolver, options) {
+  const { toolCache, manifest = loadServerManifest() } = options;
+  let moduleCount = 0;
+  for (const serverName of Object.keys(manifest.servers)) {
+    const tools = toolCache.get(serverName);
+    if (!tools || tools.length === 0) {
+      continue;
+    }
+    for (const tool of tools) {
+      const path = VirtualModuleResolver.getToolPath(serverName, tool.name);
+      const code = generateToolWrapper(tool, serverName);
+      resolver.registerModule(path, code);
+      moduleCount++;
+    }
+    const indexPath = VirtualModuleResolver.getServerIndexPath(serverName);
+    const indexCode = generateServerIndexModule(serverName, tools);
+    resolver.registerModule(indexPath, indexCode);
+    moduleCount++;
+  }
+  return moduleCount;
+}
+__name(generateFromManifest, "generateFromManifest");
+function generateServerIndexModule(serverName, tools) {
+  const lines = [];
+  lines.push("/**");
+  lines.push(` * Auto-generated index for ${serverName} MCP server tools.`);
+  lines.push(" * Re-exports all tool wrappers for convenient imports.");
+  lines.push(" */");
+  lines.push("");
+  for (const tool of tools) {
+    const fileName = sanitizeFileName(tool.name);
+    lines.push(`export * from './${fileName}.js';`);
+  }
+  return lines.join("\n");
+}
+__name(generateServerIndexModule, "generateServerIndexModule");
+async function createModuleResolver(options) {
+  const resolver = new VirtualModuleResolver();
+  await generateFromManifest(resolver, options);
+  return resolver;
+}
+__name(createModuleResolver, "createModuleResolver");
+
+// dist/sandbox/executor.js
+import { SandboxManager } from "@anthropic-ai/sandbox-runtime";
+import { spawn } from "node:child_process";
+import { writeFile, unlink, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
+import { randomUUID } from "node:crypto";
+import { transformSync } from "esbuild";
+
+// dist/sandbox/config.js
+import { tmpdir } from "node:os";
+var DEFAULT_MCP_BRIDGE_PORT = 3e3;
+function createDefaultNetworkConfig(mcpBridgePort = DEFAULT_MCP_BRIDGE_PORT) {
+  return {
+    allowedDomains: [`localhost:${mcpBridgePort}`],
+    deniedDomains: [],
+    allowLocalBinding: true
+  };
+}
+__name(createDefaultNetworkConfig, "createDefaultNetworkConfig");
+function createDefaultFilesystemConfig(additionalWritePaths = []) {
+  return {
+    denyRead: [],
+    allowWrite: [tmpdir(), ...additionalWritePaths],
+    denyWrite: []
+  };
+}
+__name(createDefaultFilesystemConfig, "createDefaultFilesystemConfig");
+function createSandboxRuntimeConfig(options = {}) {
+  const { mcpBridgePort = DEFAULT_MCP_BRIDGE_PORT, additionalWritePaths = [], networkConfig, filesystemConfig } = options;
+  return {
+    network: networkConfig ?? createDefaultNetworkConfig(mcpBridgePort),
+    filesystem: filesystemConfig ?? createDefaultFilesystemConfig(additionalWritePaths)
+  };
+}
+__name(createSandboxRuntimeConfig, "createSandboxRuntimeConfig");
+
+// dist/sandbox/executor.js
+var SandboxExecutor = class {
+  static {
+    __name(this, "SandboxExecutor");
+  }
+  constructor(options = {}) {
+    this.initialized = false;
+    this.executorConfig = options;
+    this.config = createSandboxRuntimeConfig(options);
+    this.tempDir = join(tmpdir2(), "mcp-exec");
+  }
+  /**
+   * Initialize the sandbox manager with configured restrictions
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    await mkdir(this.tempDir, { recursive: true });
+    await SandboxManager.initialize(
+      this.config,
+      void 0,
+      // No ask callback - deny by default
+      this.executorConfig.enableLogMonitor ?? false
+    );
+    this.initialized = true;
+  }
+  /**
+   * Generate the MCP helper preamble that provides the global `mcp` object
+   * for calling MCP tools via the HTTP bridge
+   */
+  getMcpPreamble() {
+    const bridgePort = this.executorConfig.mcpBridgePort ?? 3e3;
+    return `
+// ============================================================================
+// MCP-EXEC SANDBOX API
+// ============================================================================
+// Available: mcp.callTool(serverName, toolName, args)
+//
+// Usage:
+//   const result = await mcp.callTool('github', 'list_repos', { org: 'foo' });
+//   const issues = await mcp.callTool('jira', 'search_issues', { jql: 'project=X' });
+//
+// For long-running queries, prefer async patterns:
+//   const job = await mcp.callTool('splunk-async', 'create_search_job', { query: '...' });
+//   const results = await mcp.callTool('splunk-async', 'get_search_results', { job_id: job.sid });
+// ============================================================================
+
+// MCP helper for calling tools via HTTP bridge
+declare global {
+  var mcp: {
+    callTool: (server: string, tool: string, args?: Record<string, unknown>) => Promise<unknown[]>;
+  };
+}
+
+globalThis.mcp = {
+  callTool: async (server: string, tool: string, args: Record<string, unknown> = {}) => {
+    const response = await fetch('http://127.0.0.1:${bridgePort}/call', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ server, tool, args }),
+    });
+    const data = await response.json() as { success: boolean; content?: unknown[]; error?: string };
+    if (!data.success) {
+      throw new Error(data.error || 'MCP tool call failed');
+    }
+    return data.content || [];
+  },
+};
+
+`;
+  }
+  /**
+   * Execute TypeScript/JavaScript code in the sandbox
+   *
+   * @param code - The code to execute
+   * @param timeoutMs - Maximum execution time in milliseconds
+   * @returns ExecutionResult with output, error, and duration
+   */
+  async execute(code, timeoutMs) {
+    const startTime = Date.now();
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    const fileId = randomUUID();
+    const tsFilePath = join(this.tempDir, `${fileId}.ts`);
+    const jsFilePath = join(this.tempDir, `${fileId}.js`);
+    const fullCode = this.getMcpPreamble() + code;
+    try {
+      await writeFile(tsFilePath, fullCode, "utf-8");
+      const transpiled = transformSync(fullCode, {
+        loader: "ts",
+        format: "esm",
+        target: "node20"
+      });
+      await writeFile(jsFilePath, transpiled.code, "utf-8");
+      const abortController = new AbortController();
+      const timeoutId = setTimeout(() => {
+        abortController.abort();
+      }, timeoutMs);
+      try {
+        const baseCommand = `node "${jsFilePath}"`;
+        const sandboxedCommand = await SandboxManager.wrapWithSandbox(
+          baseCommand,
+          void 0,
+          // Use default shell
+          void 0,
+          // Use default config
+          abortController.signal
+        );
+        const result = await this.executeCommand(sandboxedCommand, abortController.signal);
+        clearTimeout(timeoutId);
+        return {
+          output: result.stdout,
+          error: result.stderr || void 0,
+          durationMs: Date.now() - startTime
+        };
+      } catch (execError) {
+        clearTimeout(timeoutId);
+        if (abortController.signal.aborted) {
+          return {
+            output: [],
+            error: `Execution timed out after ${timeoutMs}ms`,
+            durationMs: Date.now() - startTime
+          };
+        }
+        const errorMessage = execError instanceof Error ? execError.message : String(execError);
+        const annotatedError = SandboxManager.annotateStderrWithSandboxFailures(`node "${jsFilePath}"`, errorMessage);
+        return {
+          output: [],
+          error: annotatedError,
+          durationMs: Date.now() - startTime
+        };
+      }
+    } finally {
+      await this.cleanup(tsFilePath, jsFilePath);
+    }
+  }
+  /**
+   * Execute a command and capture its output
+   */
+  executeCommand(command, abortSignal) {
+    return new Promise((resolve, reject) => {
+      const child = spawn("sh", ["-c", command], {
+        signal: abortSignal
+      });
+      const stdout = [];
+      let stderr = "";
+      child.stdout.on("data", (data) => {
+        const lines = data.toString().split("\n").filter((line) => line.length > 0);
+        stdout.push(...lines);
+      });
+      child.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve({ stdout, stderr: stderr || null });
+        } else {
+          resolve({ stdout, stderr: stderr || `Process exited with code ${code}` });
+        }
+      });
+      child.on("error", (error) => {
+        if (error.name === "AbortError") {
+          child.kill("SIGKILL");
+          reject(new Error("Execution aborted"));
+        } else {
+          reject(error);
+        }
+      });
+    });
+  }
+  /**
+   * Cleanup temporary files
+   */
+  async cleanup(...filePaths) {
+    await Promise.all(filePaths.map(async (filePath) => {
+      try {
+        await unlink(filePath);
+      } catch {
+      }
+    }));
+  }
+  /**
+   * Reset the sandbox manager (useful for testing)
+   */
+  async reset() {
+    await SandboxManager.reset();
+    this.initialized = false;
+  }
+  /**
+   * Check if sandbox dependencies are available
+   */
+  checkDependencies() {
+    return SandboxManager.checkDependencies();
+  }
+  /**
+   * Check if sandboxing is enabled on this platform
+   */
+  isSandboxingEnabled() {
+    return SandboxManager.isSandboxingEnabled();
+  }
+  /**
+   * Get the current sandbox configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Update sandbox configuration (requires re-initialization)
+   */
+  updateConfig(newConfig) {
+    this.executorConfig = { ...this.executorConfig, ...newConfig };
+    this.config = createSandboxRuntimeConfig(this.executorConfig);
+    SandboxManager.updateConfig(this.config);
+  }
+};
+
+// dist/bridge/server.js
+import { createServer } from "http";
+import getPort from "get-port";
+import { getServerConfig, listServers as listServers2 } from "@justanothermldude/meta-mcp-core";
+
+// dist/bridge/port-cleanup.js
+import { execSync } from "child_process";
+function isMcpExecProcess(pid) {
+  try {
+    const cmdline = execSync(`ps -p ${pid} -o command=`, { encoding: "utf8" }).trim();
+    return cmdline.includes("mcp-exec") || cmdline.includes("meta-mcp");
+  } catch {
+    return false;
+  }
+}
+__name(isMcpExecProcess, "isMcpExecProcess");
+function getProcessesOnPort(port) {
+  try {
+    const result = execSync(`lsof -ti :${port}`, { encoding: "utf8" }).trim();
+    if (!result)
+      return [];
+    return result.split("\n").filter(Boolean).map((pid) => parseInt(pid, 10)).filter((pid) => !isNaN(pid));
+  } catch {
+    return [];
+  }
+}
+__name(getProcessesOnPort, "getProcessesOnPort");
+async function cleanupStaleProcess(port) {
+  const pids = getProcessesOnPort(port);
+  if (pids.length === 0)
+    return false;
+  let killedAny = false;
+  for (const pid of pids) {
+    if (isMcpExecProcess(pid)) {
+      try {
+        process.kill(pid, "SIGTERM");
+        killedAny = true;
+      } catch {
+      }
+    }
+  }
+  if (killedAny) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return killedAny;
+}
+__name(cleanupStaleProcess, "cleanupStaleProcess");
+function isPortInUse(port) {
+  return getProcessesOnPort(port).length > 0;
+}
+__name(isPortInUse, "isPortInUse");
+
+// dist/bridge/server.js
+var DEFAULT_PORT = 3e3;
+var DEFAULT_HOST = "127.0.0.1";
+var MAX_REQUEST_BODY_SIZE = 10 * 1024 * 1024;
+function stringSimilarity(a, b) {
+  const aLower = a.toLowerCase();
+  const bLower = b.toLowerCase();
+  if (aLower === bLower)
+    return 1;
+  if (aLower.includes(bLower) || bLower.includes(aLower)) {
+    return 0.8;
+  }
+  let prefixLen = 0;
+  const minLen = Math.min(aLower.length, bLower.length);
+  for (let i = 0; i < minLen; i++) {
+    if (aLower[i] === bLower[i])
+      prefixLen++;
+    else
+      break;
+  }
+  let suffixLen = 0;
+  for (let i = 0; i < minLen; i++) {
+    if (aLower[aLower.length - 1 - i] === bLower[bLower.length - 1 - i])
+      suffixLen++;
+    else
+      break;
+  }
+  const maxLen = Math.max(aLower.length, bLower.length);
+  return (prefixLen + suffixLen) / (2 * maxLen);
+}
+__name(stringSimilarity, "stringSimilarity");
+function findClosestMatch(target, candidates) {
+  if (candidates.length === 0)
+    return null;
+  let bestMatch = null;
+  let bestScore = 0;
+  const threshold = 0.3;
+  for (const candidate of candidates) {
+    const score = stringSimilarity(target, candidate);
+    if (score > bestScore && score >= threshold) {
+      bestScore = score;
+      bestMatch = candidate;
+    }
+  }
+  return bestMatch;
+}
+__name(findClosestMatch, "findClosestMatch");
+function buildServerNotFoundError(requestedServer) {
+  const servers = listServers2();
+  const serverNames = servers.map((s) => s.name);
+  let errorMsg = `Server '${requestedServer}' not found.`;
+  if (serverNames.length === 0) {
+    errorMsg += " No servers are configured. Check that servers.json is properly set up.";
+    return errorMsg;
+  }
+  const displayServers = serverNames.slice(0, 5);
+  const hasMore = serverNames.length > 5;
+  errorMsg += ` Available: ${displayServers.join(", ")}${hasMore ? ` (+${serverNames.length - 5} more)` : ""}.`;
+  const closest = findClosestMatch(requestedServer, serverNames);
+  if (closest) {
+    errorMsg += ` Did you mean '${closest}'?`;
+  }
+  return errorMsg;
+}
+__name(buildServerNotFoundError, "buildServerNotFoundError");
+function buildToolNotFoundError(serverName, requestedTool, availableTools) {
+  let errorMsg = `Tool '${requestedTool}' not found on server '${serverName}'.`;
+  if (availableTools.length === 0) {
+    errorMsg += " No tools available on this server.";
+    return errorMsg;
+  }
+  const displayTools = availableTools.slice(0, 5);
+  const hasMore = availableTools.length > 5;
+  errorMsg += ` Available tools: ${displayTools.join(", ")}${hasMore ? ` (+${availableTools.length - 5} more)` : ""}.`;
+  const closest = findClosestMatch(requestedTool, availableTools);
+  if (closest) {
+    errorMsg += ` Did you mean '${closest}'?`;
+  }
+  return errorMsg;
+}
+__name(buildToolNotFoundError, "buildToolNotFoundError");
+function buildConnectionError(serverName, originalError) {
+  let errorMsg = `Failed to connect to server '${serverName}': ${originalError}`;
+  const hints = [];
+  if (originalError.includes("ENOENT") || originalError.includes("not found")) {
+    hints.push("Check that the server command/binary exists and is in PATH");
+  }
+  if (originalError.includes("ECONNREFUSED")) {
+    hints.push("Check that the server process is running");
+  }
+  if (originalError.includes("timeout") || originalError.includes("Timeout")) {
+    hints.push("Server may be slow to start - try increasing timeout in servers.json");
+  }
+  if (originalError.includes("spawn")) {
+    hints.push("Verify the server configuration in servers.json");
+  }
+  hints.push("Is the server configured in servers.json?");
+  if (hints.length > 0) {
+    errorMsg += ` Troubleshooting: ${hints.join("; ")}.`;
+  }
+  return errorMsg;
+}
+__name(buildConnectionError, "buildConnectionError");
+var MCPBridge = class {
+  static {
+    __name(this, "MCPBridge");
+  }
+  constructor(pool, config = {}) {
+    this.server = null;
+    this.pool = pool;
+    this.preferredPort = config.port ?? DEFAULT_PORT;
+    this.port = this.preferredPort;
+    this.host = config.host ?? DEFAULT_HOST;
+  }
+  /**
+   * Start the HTTP bridge server with dynamic port allocation
+   * Prefers the configured port but falls back to any available port
+   * @returns Promise that resolves when server is listening
+   */
+  async start() {
+    this.port = await getPort({ port: this.preferredPort });
+    return new Promise((resolve, reject) => {
+      this.server = createServer((req, res) => {
+        this.handleRequest(req, res);
+      });
+      this.server.on("error", async (err) => {
+        if (err.code === "EADDRINUSE") {
+          const cleaned = await cleanupStaleProcess(this.port);
+          if (cleaned) {
+            await new Promise((r) => setTimeout(r, 200));
+            this.port = await getPort({ port: this.preferredPort });
+            try {
+              this.server?.listen(this.port, this.host, () => {
+                resolve();
+              });
+              return;
+            } catch {
+            }
+          }
+        }
+        reject(err);
+      });
+      this.server.listen(this.port, this.host, () => {
+        resolve();
+      });
+    });
+  }
+  /**
+   * Stop the HTTP bridge server
+   * @returns Promise that resolves when server is closed
+   */
+  async stop() {
+    return new Promise((resolve, reject) => {
+      if (!this.server) {
+        resolve();
+        return;
+      }
+      this.server.close((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          this.server = null;
+          resolve();
+        }
+      });
+    });
+  }
+  /**
+   * Get the port the server is listening on
+   */
+  getPort() {
+    return this.port;
+  }
+  /**
+   * Get the host the server is bound to
+   */
+  getHost() {
+    return this.host;
+  }
+  /**
+   * Check if the server is running
+   */
+  isRunning() {
+    return this.server !== null && this.server.listening;
+  }
+  /**
+   * Handle incoming HTTP requests
+   */
+  handleRequest(req, res) {
+    res.setHeader("Content-Type", "application/json");
+    res.setHeader("Access-Control-Allow-Origin", `http://${this.host}:${this.port}`);
+    res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (req.method === "POST" && req.url === "/call") {
+      this.handleCallRequest(req, res);
+    } else if (req.method === "GET" && req.url === "/health") {
+      this.handleHealthRequest(res);
+    } else {
+      this.sendError(res, 404, "Not Found");
+    }
+  }
+  /**
+   * Handle POST /call endpoint for tool invocation
+   */
+  handleCallRequest(req, res) {
+    let body = "";
+    let bodySize = 0;
+    req.on("data", (chunk) => {
+      bodySize += chunk.length;
+      if (bodySize > MAX_REQUEST_BODY_SIZE) {
+        req.destroy();
+        this.sendError(res, 413, `Request body too large. Maximum size is ${MAX_REQUEST_BODY_SIZE / 1024 / 1024}MB`);
+        return;
+      }
+      body += chunk.toString();
+    });
+    req.on("end", async () => {
+      try {
+        let request;
+        try {
+          request = JSON.parse(body);
+        } catch {
+          this.sendError(res, 400, "Invalid JSON body");
+          return;
+        }
+        if (!request.server || typeof request.server !== "string") {
+          this.sendError(res, 400, 'Missing or invalid "server" field');
+          return;
+        }
+        if (!request.tool || typeof request.tool !== "string") {
+          this.sendError(res, 400, 'Missing or invalid "tool" field');
+          return;
+        }
+        if (request.args !== void 0 && (typeof request.args !== "object" || request.args === null || Array.isArray(request.args))) {
+          this.sendError(res, 400, '"args" must be an object');
+          return;
+        }
+        let connection;
+        try {
+          connection = await this.pool.getConnection(request.server);
+        } catch (err) {
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          if (errorMsg.includes("not found") || errorMsg.includes("No server configured") || errorMsg.includes("Unknown server")) {
+            this.sendError(res, 404, buildServerNotFoundError(request.server));
+          } else {
+            this.sendError(res, 502, buildConnectionError(request.server, errorMsg));
+          }
+          return;
+        }
+        try {
+          const serverConfig = getServerConfig(request.server);
+          const defaultTimeout = process.env.MCP_DEFAULT_TIMEOUT ? parseInt(process.env.MCP_DEFAULT_TIMEOUT, 10) : void 0;
+          const timeout = serverConfig?.timeout ?? defaultTimeout;
+          const result = await connection.client.callTool(
+            {
+              name: request.tool,
+              arguments: request.args ?? {}
+            },
+            void 0,
+            // resultSchema
+            timeout ? { timeout } : void 0
+          );
+          const response = {
+            success: true,
+            content: result.content,
+            isError: result.isError
+          };
+          res.writeHead(200);
+          res.end(JSON.stringify(response));
+        } catch (err) {
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          if (errorMsg.includes("not found") || errorMsg.includes("Unknown tool") || errorMsg.includes("no such tool")) {
+            try {
+              const tools = await connection.getTools();
+              const toolNames = tools.map((t) => t.name);
+              this.sendError(res, 404, buildToolNotFoundError(request.server, request.tool, toolNames));
+            } catch {
+              this.sendError(res, 500, `Tool '${request.tool}' not found on server '${request.server}'. Unable to fetch available tools.`);
+            }
+          } else {
+            this.sendError(res, 500, `Tool execution failed: ${errorMsg}`);
+          }
+        } finally {
+          this.pool.releaseConnection(request.server);
+        }
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        this.sendError(res, 500, `Internal error: ${errorMsg}`);
+      }
+    });
+    req.on("error", (err) => {
+      this.sendError(res, 400, `Request error: ${err.message}`);
+    });
+  }
+  /**
+   * Handle GET /health endpoint
+   */
+  handleHealthRequest(res) {
+    const response = {
+      status: "ok",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    res.writeHead(200);
+    res.end(JSON.stringify(response));
+  }
+  /**
+   * Send an error response
+   */
+  sendError(res, statusCode, message) {
+    const response = {
+      success: false,
+      error: message
+    };
+    res.writeHead(statusCode);
+    res.end(JSON.stringify(response));
+  }
+};
+
+// dist/types/execution.js
+var DEFAULT_TIMEOUT_MS = 3e4;
+
+// dist/tools/execute-with-wrappers.js
+var executeCodeWithWrappersTool = {
+  name: "execute_code_with_wrappers",
+  description: 'Execute TypeScript/JavaScript code with auto-generated typed wrappers for specified MCP servers. Provides a typed API like github.createIssue({ title: "..." }) instead of raw mcp.callTool(). Multi-line code is supported - format naturally for readability.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      code: {
+        type: "string",
+        description: "The TypeScript/JavaScript code to execute. Multi-line supported - format for readability."
+      },
+      wrappers: {
+        type: "array",
+        items: { type: "string" },
+        description: "Array of MCP server names to generate typed wrappers for"
+      },
+      timeout_ms: {
+        type: "number",
+        description: `Maximum execution time in milliseconds (default: ${DEFAULT_TIMEOUT_MS})`
+      }
+    },
+    required: ["code", "wrappers"]
+  }
+};
+function isExecuteWithWrappersInput(args2) {
+  return typeof args2 === "object" && args2 !== null && "code" in args2 && typeof args2.code === "string" && "wrappers" in args2 && Array.isArray(args2.wrappers) && args2.wrappers.every((w) => typeof w === "string");
+}
+__name(isExecuteWithWrappersInput, "isExecuteWithWrappersInput");
+function getMcpPreamble(bridgePort) {
+  return `
+// MCP helper for calling tools via HTTP bridge
+declare global {
+  var mcp: {
+    callTool: (server: string, tool: string, args?: Record<string, unknown>) => Promise<unknown[]>;
+  };
+}
+
+globalThis.mcp = {
+  callTool: async (server: string, tool: string, args: Record<string, unknown> = {}) => {
+    const response = await fetch('http://127.0.0.1:${bridgePort}/call', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ server, tool, args }),
+    });
+    const data = await response.json() as { success: boolean; content?: unknown[]; error?: string };
+    if (!data.success) {
+      throw new Error(data.error || 'MCP tool call failed');
+    }
+    return data.content || [];
+  },
+};
+
+`;
+}
+__name(getMcpPreamble, "getMcpPreamble");
+function createExecuteWithWrappersHandler(pool, config = {}) {
+  const preferredPort = config.bridgeConfig?.port ?? 3e3;
+  return /* @__PURE__ */ __name(async function executeWithWrappersHandler(args2) {
+    const { code, wrappers, timeout_ms = DEFAULT_TIMEOUT_MS } = args2;
+    if (!code || typeof code !== "string") {
+      return {
+        content: [{ type: "text", text: "Error: code parameter is required and must be a string" }],
+        isError: true
+      };
+    }
+    if (!wrappers || !Array.isArray(wrappers)) {
+      return {
+        content: [{ type: "text", text: "Error: wrappers parameter is required and must be an array of strings" }],
+        isError: true
+      };
+    }
+    if (wrappers.length === 0) {
+      return {
+        content: [{ type: "text", text: "Error: wrappers array must contain at least one server name" }],
+        isError: true
+      };
+    }
+    if (timeout_ms !== void 0 && (typeof timeout_ms !== "number" || timeout_ms <= 0)) {
+      return {
+        content: [{ type: "text", text: "Error: timeout_ms must be a positive number" }],
+        isError: true
+      };
+    }
+    let result = null;
+    const bridge = new MCPBridge(pool, {
+      ...config.bridgeConfig,
+      port: preferredPort
+    });
+    try {
+      await bridge.start();
+      const actualPort = bridge.getPort();
+      const wrapperModules = [];
+      for (const serverName of wrappers) {
+        try {
+          const connection = await pool.getConnection(serverName);
+          const tools = await connection.getTools();
+          const moduleCode = generateServerModule(tools, serverName, actualPort);
+          wrapperModules.push(moduleCode);
+          pool.releaseConnection(serverName);
+        } catch (serverError) {
+          const errorMessage = serverError instanceof Error ? serverError.message : String(serverError);
+          await bridge.stop();
+          return {
+            content: [{ type: "text", text: `Error generating wrapper for server '${serverName}': ${errorMessage}` }],
+            isError: true
+          };
+        }
+      }
+      const generatedWrappers = wrapperModules.join("\n\n");
+      const mcpDictionary = generateMcpDictionary(wrappers);
+      const mcpPreamble = getMcpPreamble(actualPort);
+      const fullCode = `${generatedWrappers}
+
+${mcpDictionary}
+
+${mcpPreamble}
+${code}`;
+      const sandboxConfig = {
+        ...config.sandboxConfig,
+        mcpBridgePort: actualPort
+      };
+      const executor = new SandboxExecutor(sandboxConfig);
+      result = await executor.execute(fullCode, timeout_ms);
+      await bridge.stop();
+      return formatResult(result);
+    } catch (error) {
+      try {
+        if (bridge.isRunning()) {
+          await bridge.stop();
+        }
+      } catch {
+      }
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return formatErrorResult(errorMessage, result);
+    }
+  }, "executeWithWrappersHandler");
+}
+__name(createExecuteWithWrappersHandler, "createExecuteWithWrappersHandler");
+function formatResult(result) {
+  const lines = [];
+  if (result.output.length > 0) {
+    lines.push(...result.output);
+  }
+  if (result.error) {
+    lines.push(`[stderr]: ${result.error}`);
+  }
+  lines.push(`[Execution completed in ${result.durationMs}ms]`);
+  const hasError = !!result.error;
+  return {
+    content: [{ type: "text", text: lines.join("\n") }],
+    isError: hasError
+  };
+}
+__name(formatResult, "formatResult");
+function formatErrorResult(errorMessage, partialResult) {
+  const lines = [];
+  if (partialResult?.output.length) {
+    lines.push("[Partial output]:");
+    lines.push(...partialResult.output);
+    lines.push("");
+  }
+  lines.push(`Error: ${errorMessage}`);
+  if (partialResult?.durationMs) {
+    lines.push(`[Execution failed after ${partialResult.durationMs}ms]`);
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }],
+    isError: true
+  };
+}
+__name(formatErrorResult, "formatErrorResult");
+
+// dist/server.js
+var VERSION = "0.1.0";
+function createMcpExecServer(pool, config = {}) {
+  const server = new Server({
+    name: "mcp-exec",
+    version: VERSION
+  }, {
+    capabilities: {
+      tools: {}
+    }
+  });
+  const listServersHandler = createListServersHandler();
+  const getToolSchemaHandler = createGetToolSchemaHandler(pool);
+  const executeWithWrappersHandler = createExecuteWithWrappersHandler(pool, config.handlerConfig);
+  const tools = [
+    listAvailableMcpServersTool,
+    getMcpToolSchemaTool,
+    executeCodeWithWrappersTool
+  ];
+  const listToolsHandler = /* @__PURE__ */ __name(async () => ({ tools }), "listToolsHandler");
+  const callToolRequestHandler = /* @__PURE__ */ __name(async (params) => {
+    const { name, arguments: args2 = {} } = params;
+    switch (name) {
+      case "list_available_mcp_servers": {
+        if (!isListServersInput(args2)) {
+          return {
+            content: [{ type: "text", text: "Error: Invalid arguments for list_available_mcp_servers" }],
+            isError: true
+          };
+        }
+        const result = await listServersHandler(args2);
+        return {
+          content: result.content,
+          isError: result.isError
+        };
+      }
+      case "get_mcp_tool_schema": {
+        if (!isGetToolSchemaInput(args2)) {
+          return {
+            content: [{ type: "text", text: "Error: Invalid arguments for get_mcp_tool_schema. Required: server (string), tool (string)" }],
+            isError: true
+          };
+        }
+        const result = await getToolSchemaHandler(args2);
+        return {
+          content: result.content,
+          isError: result.isError
+        };
+      }
+      case "execute_code_with_wrappers": {
+        if (!isExecuteWithWrappersInput(args2)) {
+          return {
+            content: [{ type: "text", text: "Error: Invalid arguments for execute_code_with_wrappers. Required: code (string), wrappers (string[])" }],
+            isError: true
+          };
+        }
+        const result = await executeWithWrappersHandler(args2);
+        return {
+          content: result.content,
+          isError: result.isError
+        };
+      }
+      default:
+        return {
+          content: [{ type: "text", text: `Unknown tool: ${name}` }],
+          isError: true
+        };
+    }
+  }, "callToolRequestHandler");
+  server.setRequestHandler(ListToolsRequestSchema, listToolsHandler);
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    return callToolRequestHandler(request.params);
+  });
+  const shutdown = /* @__PURE__ */ __name(async () => {
+  }, "shutdown");
+  return {
+    server,
+    listToolsHandler,
+    callToolHandler: callToolRequestHandler,
+    shutdown
+  };
+}
+__name(createMcpExecServer, "createMcpExecServer");
+
+// dist/index.js
+import { ServerPool, createConnection, getServerConfig as getServerConfig2, loadServerManifest as loadServerManifest2 } from "@justanothermldude/meta-mcp-core";
+var APP_NAME = "mcp-exec";
+var VERSION2 = "1.2.0";
+var defaultExecutor = null;
 function getDefaultExecutor() {
-    if (!defaultExecutor) {
-        defaultExecutor = new SandboxExecutor();
-    }
-    return defaultExecutor;
-}
-/**
- * Execute code in a sandboxed environment using @anthropic-ai/sandbox-runtime.
- * Provides OS-level isolation (sandbox-exec on macOS, bubblewrap on Linux).
- *
- * @param input - The code execution input parameters
- * @returns Promise resolving to execution result
- */
-export async function executeCode(input) {
-    const { code, timeout_ms = DEFAULT_TIMEOUT_MS } = input;
-    const executor = getDefaultExecutor();
-    return executor.execute(code, timeout_ms);
-}
-/**
- * Create a new SandboxExecutor with custom configuration
- * @param config - Configuration options for the sandbox
- * @returns New SandboxExecutor instance
- */
-export function createExecutor(config) {
-    return new SandboxExecutor(config);
-}
-// Handle --version and --help flags
-const args = process.argv.slice(2);
-if (args.includes('--version') || args.includes('-v')) {
-    console.log(VERSION);
-    process.exit(0);
+  if (!defaultExecutor) {
+    defaultExecutor = new SandboxExecutor();
+  }
+  return defaultExecutor;
+}
+__name(getDefaultExecutor, "getDefaultExecutor");
+async function executeCode(input) {
+  const { code, timeout_ms = DEFAULT_TIMEOUT_MS } = input;
+  const executor = getDefaultExecutor();
+  return executor.execute(code, timeout_ms);
+}
+__name(executeCode, "executeCode");
+function createExecutor(config) {
+  return new SandboxExecutor(config);
+}
+__name(createExecutor, "createExecutor");
+var args = process.argv.slice(2);
+if (args.includes("--version") || args.includes("-v")) {
+  console.log(VERSION2);
+  process.exit(0);
 }
-if (args.includes('--help') || args.includes('-h')) {
-    console.log(`${APP_NAME} v${VERSION}
+if (args.includes("--help") || args.includes("-h")) {
+  console.log(`${APP_NAME} v${VERSION2}
 
 An MCP server for executing TypeScript/JavaScript code in sandboxed environments
 with access to MCP tools via HTTP bridge.
@@ -75,51 +1483,76 @@ Environment:
   SERVERS_CONFIG    Path to servers.json config file
                     Default: ~/.meta-mcp/servers.json
 `);
-    process.exit(0);
+  process.exit(0);
 }
 async function main() {
-    // Load config on startup
-    const configPath = process.env.SERVERS_CONFIG;
-    if (configPath) {
-        process.stderr.write(`Loading config from: ${configPath}\n`);
-    }
-    // Load server manifest (required before getServerConfig works)
-    loadServerManifest();
-    // Create connection factory with Gateway auth support
-    const connectionFactory = async (serverId) => {
-        const config = getServerConfig(serverId);
-        if (!config) {
-            throw new Error(`Server config not found: ${serverId}`);
-        }
-        return createConnection({ ...config, name: serverId }, {
-            gatewayAuth: { useCursorToken: true }
-        });
-    };
-    // Initialize pool
-    const pool = new ServerPool(connectionFactory);
-    // Create server
-    const { server, shutdown } = createMcpExecServer(pool);
-    // Graceful shutdown handlers
-    const handleShutdown = async () => {
-        process.stderr.write('Shutting down...\n');
-        await shutdown();
-        await pool.shutdown();
-        await server.close();
-        process.exit(0);
-    };
-    process.on('SIGINT', handleShutdown);
-    process.on('SIGTERM', handleShutdown);
-    // Connect via stdio
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    process.stderr.write('mcp-exec server running on stdio\n');
-}
-// Only run main if this is the entry point (not when imported as a module)
-const isMainModule = process.argv[1]?.endsWith('index.js') || process.argv[1]?.endsWith('mcp-exec');
-if (isMainModule && !args.includes('--no-server')) {
-    main().catch((error) => {
-        console.error('Fatal error:', error);
-        process.exit(1);
+  const configPath = process.env.SERVERS_CONFIG;
+  if (configPath) {
+    process.stderr.write(`Loading config from: ${configPath}
+`);
+  }
+  loadServerManifest2();
+  const connectionFactory = /* @__PURE__ */ __name(async (serverId) => {
+    const config = getServerConfig2(serverId);
+    if (!config) {
+      throw new Error(`Server config not found: ${serverId}`);
+    }
+    return createConnection({ ...config, name: serverId }, {
+      gatewayAuth: { useCursorToken: true }
     });
+  }, "connectionFactory");
+  const pool = new ServerPool(connectionFactory);
+  const { server, shutdown } = createMcpExecServer(pool);
+  const handleShutdown = /* @__PURE__ */ __name(async () => {
+    process.stderr.write("Shutting down...\n");
+    await shutdown();
+    await pool.shutdown();
+    await server.close();
+    process.exit(0);
+  }, "handleShutdown");
+  process.on("SIGINT", handleShutdown);
+  process.on("SIGTERM", handleShutdown);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.stderr.write("mcp-exec server running on stdio\n");
+}
+__name(main, "main");
+var isMainModule = process.argv[1]?.endsWith("index.js") || process.argv[1]?.endsWith("mcp-exec");
+if (isMainModule && !args.includes("--no-server")) {
+  main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+  });
 }
-//# sourceMappingURL=index.js.map
+export {
+  APP_NAME,
+  DEFAULT_MCP_BRIDGE_PORT,
+  DEFAULT_TIMEOUT_MS,
+  MCPBridge,
+  SandboxExecutor,
+  VERSION2 as VERSION,
+  VirtualModuleResolver,
+  cleanupStaleProcess,
+  createDefaultFilesystemConfig,
+  createDefaultNetworkConfig,
+  createExecuteWithWrappersHandler,
+  createExecutor,
+  createGetToolSchemaHandler,
+  createListServersHandler,
+  createMcpExecServer,
+  createModuleResolver,
+  createSandboxRuntimeConfig,
+  executeCode,
+  executeCodeWithWrappersTool,
+  generateFromManifest,
+  generateMcpDictionary,
+  generateServerModule,
+  generateToolWrapper,
+  getMcpToolSchemaTool,
+  isExecuteWithWrappersInput,
+  isGetToolSchemaInput,
+  isListServersInput,
+  isPortInUse,
+  listAvailableMcpServersTool,
+  normalizeName
+};