@mcpjam/inspector 0.9.2 → 0.9.4

package/dist/main/main.cjs

@@ -1,1315 +0,0 @@
-"use strict";
-const electron = require("electron");
-const nodeServer = require("@hono/node-server");
-const path = require("path");
-const hono = require("hono");
-const cors = require("hono/cors");
-const logger = require("hono/logger");
-const serveStatic = require("@hono/node-server/serve-static");
-const mcp$1 = require("@mastra/mcp");
-const zodToJsonSchema = require("zod-to-json-schema");
-const agent = require("@mastra/core/agent");
-const anthropic = require("@ai-sdk/anthropic");
-const openai = require("@ai-sdk/openai");
-const ollamaAiProvider = require("ollama-ai-provider");
-const log = require("electron-log");
-const updateElectronApp = require("update-electron-app");
-const fs = require("fs/promises");
-function validateServerConfig(serverConfig) {
-  var _a, _b, _c;
-  if (!serverConfig) {
-    return {
-      success: false,
-      error: {
-        message: "Server configuration is required",
-        status: 400
-      }
-    };
-  }
-  const config = { ...serverConfig };
-  if (config.url) {
-    try {
-      if (typeof config.url === "string") {
-        config.url = new URL(config.url);
-      } else if (typeof config.url === "object" && !config.url.href) {
-        return {
-          success: false,
-          error: {
-            message: "Invalid URL configuration",
-            status: 400
-          }
-        };
-      }
-      if ((_a = config.oauth) == null ? void 0 : _a.access_token) {
-        const authHeaders = {
-          Authorization: `Bearer ${config.oauth.access_token}`,
-          ...((_b = config.requestInit) == null ? void 0 : _b.headers) || {}
-        };
-        config.requestInit = {
-          ...config.requestInit,
-          headers: authHeaders
-        };
-        config.eventSourceInit = {
-          fetch(input, init) {
-            var _a2;
-            const headers = new Headers((init == null ? void 0 : init.headers) || {});
-            headers.set(
-              "Authorization",
-              `Bearer ${config.oauth.access_token}`
-            );
-            if ((_a2 = config.requestInit) == null ? void 0 : _a2.headers) {
-              const requestHeaders = new Headers(config.requestInit.headers);
-              requestHeaders.forEach((value, key) => {
-                if (key.toLowerCase() !== "authorization") {
-                  headers.set(key, value);
-                }
-              });
-            }
-            return fetch(input, {
-              ...init,
-              headers
-            });
-          }
-        };
-      } else if ((_c = config.requestInit) == null ? void 0 : _c.headers) {
-        config.eventSourceInit = {
-          fetch(input, init) {
-            const headers = new Headers((init == null ? void 0 : init.headers) || {});
-            const requestHeaders = new Headers(config.requestInit.headers);
-            requestHeaders.forEach((value, key) => {
-              headers.set(key, value);
-            });
-            return fetch(input, {
-              ...init,
-              headers
-            });
-          }
-        };
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: {
-          message: `Invalid URL format: ${error}`,
-          status: 400
-        }
-      };
-    }
-  }
-  return {
-    success: true,
-    config
-  };
-}
-function createMCPClient(config, id) {
-  return new mcp$1.MCPClient({
-    id,
-    servers: {
-      server: config
-    }
-  });
-}
-const validateMultipleServerConfigs = (serverConfigs) => {
-  if (!serverConfigs || Object.keys(serverConfigs).length === 0) {
-    return {
-      success: false,
-      error: {
-        message: "At least one server configuration is required",
-        status: 400
-      }
-    };
-  }
-  const validConfigs = {};
-  const errors = {};
-  let hasErrors = false;
-  for (const [serverName, serverConfig] of Object.entries(serverConfigs)) {
-    const validationResult = validateServerConfig(serverConfig);
-    if (validationResult.success && validationResult.config) {
-      validConfigs[serverName] = validationResult.config;
-    } else {
-      hasErrors = true;
-      let errorMessage = "Configuration validation failed";
-      if (validationResult.error) {
-        errorMessage = validationResult.error.message;
-      }
-      errors[serverName] = errorMessage;
-    }
-  }
-  if (!hasErrors) {
-    return {
-      success: true,
-      validConfigs
-    };
-  }
-  if (Object.keys(validConfigs).length > 0) {
-    return {
-      success: false,
-      validConfigs,
-      errors
-    };
-  }
-  return {
-    success: false,
-    errors,
-    error: {
-      message: "All server configurations failed validation",
-      status: 400
-    }
-  };
-};
-function createMCPClientWithMultipleConnections(serverConfigs) {
-  const normalizedConfigs = {};
-  for (const [serverName, config] of Object.entries(serverConfigs)) {
-    const normalizedName = normalizeServerConfigName(serverName);
-    normalizedConfigs[normalizedName] = config;
-  }
-  return new mcp$1.MCPClient({
-    id: `chat-${Date.now()}`,
-    servers: normalizedConfigs
-  });
-}
-function normalizeServerConfigName(serverName) {
-  return serverName.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
-}
-const connect = new hono.Hono();
-connect.post("/", async (c) => {
-  try {
-    const { serverConfig } = await c.req.json();
-    const validation = validateServerConfig(serverConfig);
-    if (!validation.success) {
-      const error = validation.error;
-      return c.json(
-        {
-          success: false,
-          error: error.message
-        },
-        error.status
-      );
-    }
-    let client;
-    try {
-      client = createMCPClient(validation.config, `test-${Date.now()}`);
-    } catch (error) {
-      return c.json(
-        {
-          success: false,
-          error: `Failed to create a MCP client. Please double check your server configuration: ${JSON.stringify(serverConfig)}`,
-          details: error instanceof Error ? error.message : "Unknown error"
-        },
-        500
-      );
-    }
-    try {
-      await client.getTools();
-      await client.disconnect();
-      return c.json({
-        success: true
-      });
-    } catch (error) {
-      return c.json(
-        {
-          success: false,
-          error: `MCP configuration is invalid. Please double check your server configuration: ${JSON.stringify(serverConfig)}`,
-          details: error instanceof Error ? error.message : "Unknown error"
-        },
-        500
-      );
-    }
-  } catch (error) {
-    return c.json(
-      {
-        success: false,
-        error: "Failed to parse request body",
-        details: error instanceof Error ? error.message : "Unknown error"
-      },
-      400
-    );
-  }
-});
-const tools = new hono.Hono();
-const pendingElicitations$1 = /* @__PURE__ */ new Map();
-tools.post("/", async (c) => {
-  let client = null;
-  let encoder = null;
-  let streamController = null;
-  let action;
-  let toolName;
-  try {
-    const requestData = await c.req.json();
-    action = requestData.action;
-    toolName = requestData.toolName;
-    const { serverConfig, parameters, requestId, response } = requestData;
-    if (!action || !["list", "execute", "respond"].includes(action)) {
-      return c.json(
-        {
-          success: false,
-          error: "Action must be 'list', 'execute', or 'respond'"
-        },
-        400
-      );
-    }
-    if (action === "respond") {
-      if (!requestId) {
-        return c.json(
-          {
-            success: false,
-            error: "requestId is required for respond action"
-          },
-          400
-        );
-      }
-      const pending = pendingElicitations$1.get(requestId);
-      if (!pending) {
-        return c.json(
-          {
-            success: false,
-            error: "No pending elicitation found for this requestId"
-          },
-          404
-        );
-      }
-      pending.resolve(response);
-      pendingElicitations$1.delete(requestId);
-      return c.json({ success: true });
-    }
-    const validation = validateServerConfig(serverConfig);
-    if (!validation.success) {
-      return c.json(
-        { success: false, error: validation.error.message },
-        validation.error.status
-      );
-    }
-    encoder = new TextEncoder();
-    const readableStream = new ReadableStream({
-      async start(controller) {
-        streamController = controller;
-        try {
-          const clientId = `tools-${action}-${Date.now()}`;
-          client = createMCPClient(validation.config, clientId);
-          if (action === "list") {
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "tools_loading",
-                  message: "Fetching tools from server..."
-                })}
-
-`
-              )
-            );
-            const tools2 = await client.getTools();
-            const toolsWithJsonSchema = Object.fromEntries(
-              Object.entries(tools2).map(([toolName2, tool]) => {
-                return [
-                  toolName2,
-                  {
-                    ...tool,
-                    inputSchema: zodToJsonSchema.zodToJsonSchema(
-                      tool.inputSchema
-                    )
-                  }
-                ];
-              })
-            );
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "tools_list",
-                  tools: toolsWithJsonSchema
-                })}
-
-`
-              )
-            );
-          } else if (action === "execute") {
-            if (!toolName) {
-              controller.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({
-                    type: "tool_error",
-                    error: "Tool name is required for execution"
-                  })}
-
-`
-                )
-              );
-              return;
-            }
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "tool_executing",
-                  toolName,
-                  parameters: parameters || {},
-                  message: "Executing tool..."
-                })}
-
-`
-              )
-            );
-            const tools2 = await client.getTools();
-            const tool = tools2[toolName];
-            if (!tool) {
-              controller.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({
-                    type: "tool_error",
-                    error: `Tool '${toolName}' not found`
-                  })}
-
-`
-                )
-              );
-              return;
-            }
-            const toolArgs = parameters && typeof parameters === "object" ? parameters : {};
-            const elicitationHandler = async (elicitationRequest) => {
-              const requestId2 = `elicit_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-              if (streamController && encoder) {
-                streamController.enqueue(
-                  encoder.encode(
-                    `data: ${JSON.stringify({
-                      type: "elicitation_request",
-                      requestId: requestId2,
-                      message: elicitationRequest.message,
-                      schema: elicitationRequest.requestedSchema,
-                      timestamp: /* @__PURE__ */ new Date()
-                    })}
-
-`
-                  )
-                );
-              }
-              return new Promise((resolve, reject) => {
-                pendingElicitations$1.set(requestId2, { resolve, reject });
-                setTimeout(() => {
-                  if (pendingElicitations$1.has(requestId2)) {
-                    pendingElicitations$1.delete(requestId2);
-                    reject(new Error("Elicitation timeout"));
-                  }
-                }, 3e5);
-              });
-            };
-            if (client.elicitation && client.elicitation.onRequest) {
-              const serverName = "server";
-              client.elicitation.onRequest(serverName, elicitationHandler);
-            }
-            const result = await tool.execute({
-              context: toolArgs
-            });
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "tool_result",
-                  toolName,
-                  result
-                })}
-
-`
-              )
-            );
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "elicitation_complete",
-                  toolName
-                })}
-
-`
-              )
-            );
-          }
-          controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : "Unknown error";
-          controller.enqueue(
-            encoder.encode(
-              `data: ${JSON.stringify({
-                type: "tool_error",
-                error: errorMsg
-              })}
-
-`
-            )
-          );
-        } finally {
-          if (client) {
-            await client.disconnect();
-          }
-          controller.close();
-        }
-      }
-    });
-    return new Response(readableStream, {
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
-      }
-    });
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : "Unknown error";
-    if (client) {
-      try {
-        await client.disconnect();
-      } catch (cleanupError) {
-      }
-    }
-    return c.json(
-      {
-        success: false,
-        error: errorMsg
-      },
-      500
-    );
-  }
-});
-const resources = new hono.Hono();
-resources.post("/list", async (c) => {
-  try {
-    const { serverConfig } = await c.req.json();
-    const validation = validateServerConfig(serverConfig);
-    if (!validation.success) {
-      return c.json(
-        { success: false, error: validation.error.message },
-        validation.error.status
-      );
-    }
-    const client = createMCPClient(
-      validation.config,
-      `resources-list-${Date.now()}`
-    );
-    try {
-      const resources2 = await client.resources.list();
-      await client.disconnect();
-      return c.json({ resources: resources2 });
-    } catch (error) {
-      await client.disconnect();
-      throw error;
-    }
-  } catch (error) {
-    console.error("Error fetching resources:", error);
-    return c.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
-      500
-    );
-  }
-});
-resources.post("/read", async (c) => {
-  try {
-    const { serverConfig, uri } = await c.req.json();
-    const validation = validateServerConfig(serverConfig);
-    if (!validation.success) {
-      return c.json(
-        { success: false, error: validation.error.message },
-        validation.error.status
-      );
-    }
-    if (!uri) {
-      return c.json(
-        {
-          success: false,
-          error: "Resource URI is required"
-        },
-        400
-      );
-    }
-    const client = createMCPClient(
-      validation.config,
-      `resources-read-${Date.now()}`
-    );
-    try {
-      const content = await client.resources.read("server", uri);
-      await client.disconnect();
-      return c.json({ content });
-    } catch (error) {
-      await client.disconnect();
-      throw error;
-    }
-  } catch (error) {
-    console.error("Error reading resource:", error);
-    return c.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
-      500
-    );
-  }
-});
-const prompts = new hono.Hono();
-prompts.post("/list", async (c) => {
-  try {
-    const { serverConfig } = await c.req.json();
-    const validation = validateServerConfig(serverConfig);
-    if (!validation.success) {
-      return c.json(
-        { success: false, error: validation.error.message },
-        validation.error.status
-      );
-    }
-    const client = createMCPClient(
-      validation.config,
-      `prompts-list-${Date.now()}`
-    );
-    try {
-      const prompts2 = await client.prompts.list();
-      await client.disconnect();
-      return c.json({ prompts: prompts2 });
-    } catch (error) {
-      await client.disconnect();
-      throw error;
-    }
-  } catch (error) {
-    console.error("Error fetching prompts:", error);
-    return c.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
-      500
-    );
-  }
-});
-prompts.post("/get", async (c) => {
-  try {
-    const { serverConfig, name, args } = await c.req.json();
-    const validation = validateServerConfig(serverConfig);
-    if (!validation.success) {
-      return c.json(
-        { success: false, error: validation.error.message },
-        validation.error.status
-      );
-    }
-    if (!name) {
-      return c.json(
-        {
-          success: false,
-          error: "Prompt name is required"
-        },
-        400
-      );
-    }
-    const client = createMCPClient(
-      validation.config,
-      `prompts-get-${Date.now()}`
-    );
-    try {
-      const content = await client.prompts.get({
-        serverName: "server",
-        name,
-        args: args || {}
-      });
-      await client.disconnect();
-      return c.json({ content });
-    } catch (error) {
-      await client.disconnect();
-      throw error;
-    }
-  } catch (error) {
-    console.error("Error getting prompt:", error);
-    return c.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
-      500
-    );
-  }
-});
-const chat = new hono.Hono();
-const pendingElicitations = /* @__PURE__ */ new Map();
-chat.post("/", async (c) => {
-  let client = null;
-  try {
-    const requestData = await c.req.json();
-    const {
-      serverConfigs,
-      model,
-      apiKey,
-      systemPrompt,
-      messages,
-      ollamaBaseUrl,
-      action,
-      requestId,
-      response
-    } = requestData;
-    if (action === "elicitation_response") {
-      if (!requestId) {
-        return c.json(
-          {
-            success: false,
-            error: "requestId is required for elicitation_response action"
-          },
-          400
-        );
-      }
-      const pending = pendingElicitations.get(requestId);
-      if (!pending) {
-        return c.json(
-          {
-            success: false,
-            error: "No pending elicitation found for this requestId"
-          },
-          404
-        );
-      }
-      pending.resolve(response);
-      pendingElicitations.delete(requestId);
-      return c.json({ success: true });
-    }
-    if (!model || !model.id || !apiKey || !messages) {
-      return c.json(
-        {
-          success: false,
-          error: "model (with id), apiKey, and messages are required"
-        },
-        400
-      );
-    }
-    if (serverConfigs && Object.keys(serverConfigs).length > 0) {
-      const validation = validateMultipleServerConfigs(serverConfigs);
-      if (!validation.success) {
-        return c.json(
-          {
-            success: false,
-            error: validation.error.message,
-            details: validation.errors
-          },
-          validation.error.status
-        );
-      }
-      client = createMCPClientWithMultipleConnections(validation.validConfigs);
-    } else {
-      client = new mcp$1.MCPClient({
-        id: `chat-${Date.now()}`,
-        servers: {}
-      });
-    }
-    const tools2 = await client.getTools();
-    const llmModel = getLlmModel(model, apiKey, ollamaBaseUrl);
-    let toolCallId = 0;
-    let streamController = null;
-    let encoder = null;
-    const elicitationHandler = async (elicitationRequest) => {
-      const requestId2 = `elicit_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
-      if (streamController && encoder) {
-        streamController.enqueue(
-          encoder.encode(
-            `data: ${JSON.stringify({
-              type: "elicitation_request",
-              requestId: requestId2,
-              message: elicitationRequest.message,
-              schema: elicitationRequest.requestedSchema,
-              timestamp: /* @__PURE__ */ new Date()
-            })}
-
-`
-          )
-        );
-      }
-      return new Promise((resolve, reject) => {
-        pendingElicitations.set(requestId2, { resolve, reject });
-        setTimeout(() => {
-          if (pendingElicitations.has(requestId2)) {
-            pendingElicitations.delete(requestId2);
-            reject(new Error("Elicitation timeout"));
-          }
-        }, 3e5);
-      });
-    };
-    if (client.elicitation && client.elicitation.onRequest && serverConfigs) {
-      for (const serverName of Object.keys(serverConfigs)) {
-        const normalizedName = serverName.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
-        client.elicitation.onRequest(normalizedName, elicitationHandler);
-      }
-    }
-    const originalTools = tools2 && Object.keys(tools2).length > 0 ? tools2 : {};
-    const wrappedTools = {};
-    for (const [name, tool] of Object.entries(originalTools)) {
-      wrappedTools[name] = {
-        ...tool,
-        execute: async (params) => {
-          const currentToolCallId = ++toolCallId;
-          if (streamController && encoder) {
-            streamController.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "tool_call",
-                  toolCall: {
-                    id: currentToolCallId,
-                    name,
-                    parameters: params,
-                    timestamp: /* @__PURE__ */ new Date(),
-                    status: "executing"
-                  }
-                })}
-
-`
-              )
-            );
-          }
-          try {
-            const result = await tool.execute(params);
-            if (streamController && encoder) {
-              streamController.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({
-                    type: "tool_result",
-                    toolResult: {
-                      id: currentToolCallId,
-                      toolCallId: currentToolCallId,
-                      result,
-                      timestamp: /* @__PURE__ */ new Date()
-                    }
-                  })}
-
-`
-                )
-              );
-            }
-            return result;
-          } catch (error) {
-            if (streamController && encoder) {
-              streamController.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({
-                    type: "tool_result",
-                    toolResult: {
-                      id: currentToolCallId,
-                      toolCallId: currentToolCallId,
-                      error: error instanceof Error ? error.message : String(error),
-                      timestamp: /* @__PURE__ */ new Date()
-                    }
-                  })}
-
-`
-                )
-              );
-            }
-            throw error;
-          }
-        }
-      };
-    }
-    const agent$1 = new agent.Agent({
-      name: "MCP Chat Agent",
-      instructions: systemPrompt || "You are a helpful assistant with access to MCP tools.",
-      model: llmModel,
-      tools: Object.keys(wrappedTools).length > 0 ? wrappedTools : void 0
-    });
-    const formattedMessages = messages.map((msg) => ({
-      role: msg.role,
-      content: msg.content
-    }));
-    const stream = await agent$1.stream(formattedMessages, {
-      maxSteps: 10
-      // Allow up to 10 steps for tool usage
-    });
-    encoder = new TextEncoder();
-    const readableStream = new ReadableStream({
-      async start(controller) {
-        streamController = controller;
-        try {
-          let hasContent = false;
-          for await (const chunk of stream.textStream) {
-            if (chunk && chunk.trim()) {
-              hasContent = true;
-              controller.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({ type: "text", content: chunk })}
-
-`
-                )
-              );
-            }
-          }
-          if (!hasContent) {
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({ type: "text", content: "I apologize, but I couldn't generate a response. Please try again." })}
-
-`
-              )
-            );
-          }
-          controller.enqueue(
-            encoder.encode(
-              `data: ${JSON.stringify({
-                type: "elicitation_complete"
-              })}
-
-`
-            )
-          );
-          controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-        } catch (error) {
-          console.error("Streaming error:", error);
-          controller.enqueue(
-            encoder.encode(
-              `data: ${JSON.stringify({
-                type: "error",
-                error: error instanceof Error ? error.message : "Unknown error"
-              })}
-
-`
-            )
-          );
-        } finally {
-          if (client) {
-            try {
-              await client.disconnect();
-            } catch (cleanupError) {
-              console.warn(
-                "Error cleaning up MCP client after streaming:",
-                cleanupError
-              );
-            }
-          }
-          controller.close();
-        }
-      }
-    });
-    return new Response(readableStream, {
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
-      }
-    });
-  } catch (error) {
-    console.error("Error in chat API:", error);
-    if (client) {
-      try {
-        await client.disconnect();
-      } catch (cleanupError) {
-        console.warn("Error cleaning up MCP client after error:", cleanupError);
-      }
-    }
-    return c.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
-      500
-    );
-  }
-});
-const getLlmModel = (modelDefinition, apiKey, ollamaBaseUrl) => {
-  if (!modelDefinition || !modelDefinition.id || !modelDefinition.provider) {
-    throw new Error(
-      `Invalid model definition: ${JSON.stringify(modelDefinition)}`
-    );
-  }
-  switch (modelDefinition.provider) {
-    case "anthropic":
-      return anthropic.createAnthropic({ apiKey })(modelDefinition.id);
-    case "openai":
-      return openai.createOpenAI({ apiKey })(modelDefinition.id);
-    case "ollama":
-      const baseUrl = ollamaBaseUrl || "http://localhost:11434";
-      return ollamaAiProvider.createOllama({
-        baseURL: `${baseUrl}/api`
-        // Configurable Ollama API endpoint
-      })(modelDefinition.id, {
-        simulateStreaming: true
-        // Enable streaming for Ollama models
-      });
-    default:
-      throw new Error(
-        `Unsupported provider: ${modelDefinition.provider} for model: ${modelDefinition.id}`
-      );
-  }
-};
-const oauth = new hono.Hono();
-oauth.get("/metadata", async (c) => {
-  try {
-    const url = c.req.query("url");
-    if (!url) {
-      return c.json({ error: "Missing url parameter" }, 400);
-    }
-    let metadataUrl;
-    try {
-      metadataUrl = new URL(url);
-      if (metadataUrl.protocol !== "https:") {
-        return c.json({ error: "Only HTTPS URLs are allowed" }, 400);
-      }
-    } catch (error) {
-      return c.json({ error: "Invalid URL format" }, 400);
-    }
-    const response = await fetch(metadataUrl.toString(), {
-      method: "GET",
-      headers: {
-        Accept: "application/json",
-        "User-Agent": "MCP-Inspector/1.0"
-      }
-    });
-    if (!response.ok) {
-      return c.json(
-        {
-          error: `Failed to fetch OAuth metadata: ${response.status} ${response.statusText}`
-        },
-        response.status
-      );
-    }
-    const metadata = await response.json();
-    return c.json(metadata);
-  } catch (error) {
-    console.error("OAuth metadata proxy error:", error);
-    return c.json(
-      {
-        error: error instanceof Error ? error.message : "Unknown error occurred"
-      },
-      500
-    );
-  }
-});
-const mcp = new hono.Hono();
-mcp.get("/health", (c) => {
-  return c.json({
-    service: "MCP API",
-    status: "ready",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  });
-});
-mcp.route("/chat", chat);
-mcp.route("/connect", connect);
-mcp.route("/tools", tools);
-mcp.route("/resources", resources);
-mcp.route("/prompts", prompts);
-mcp.route("/oauth", oauth);
-function createHonoApp() {
-  const app = new hono.Hono();
-  app.use("*", logger.logger());
-  app.use(
-    "*",
-    cors.cors({
-      origin: [
-        "http://localhost:8080",
-        "http://localhost:3000",
-        "http://localhost:3001",
-        "http://127.0.0.1:3001",
-        "http://127.0.0.1:3000"
-      ],
-      credentials: true
-    })
-  );
-  app.route("/api/mcp", mcp);
-  app.get("/health", (c) => {
-    return c.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-  });
-  const isElectron = process.env.ELECTRON_APP === "true";
-  if (process.env.NODE_ENV === "production" || isElectron) {
-    app.use("/*", serveStatic.serveStatic({ root: "./dist/client" }));
-    app.get("*", (c) => {
-      const path2 = c.req.path;
-      if (path2.startsWith("/api/")) {
-        return c.notFound();
-      }
-      return serveStatic.serveStatic({ path: "./dist/client/index.html" })(c);
-    });
-  } else {
-    app.get("/", (c) => {
-      return c.json({
-        message: "MCP Inspector API Server",
-        environment: "development",
-        frontend: "http://localhost:8080"
-      });
-    });
-  }
-  return app;
-}
-function registerAppListeners(mainWindow2) {
-  electron.ipcMain.handle("app:version", () => {
-    return electron.app.getVersion();
-  });
-  electron.ipcMain.handle("app:platform", () => {
-    return process.platform;
-  });
-}
-function registerWindowListeners(mainWindow2) {
-  electron.ipcMain.on("window:minimize", () => {
-    mainWindow2.minimize();
-  });
-  electron.ipcMain.on("window:maximize", () => {
-    if (mainWindow2.isMaximized()) {
-      mainWindow2.unmaximize();
-    } else {
-      mainWindow2.maximize();
-    }
-  });
-  electron.ipcMain.on("window:close", () => {
-    mainWindow2.close();
-  });
-  electron.ipcMain.handle("window:is-maximized", () => {
-    return mainWindow2.isMaximized();
-  });
-}
-function registerFileListeners(mainWindow2) {
-  electron.ipcMain.handle("dialog:open", async (event, options = {}) => {
-    const result = await electron.dialog.showOpenDialog(mainWindow2, {
-      properties: ["openFile"],
-      filters: [
-        { name: "JSON Files", extensions: ["json"] },
-        { name: "All Files", extensions: ["*"] }
-      ],
-      ...options
-    });
-    return result.canceled ? void 0 : result.filePaths;
-  });
-  electron.ipcMain.handle("dialog:save", async (event, data) => {
-    const result = await electron.dialog.showSaveDialog(mainWindow2, {
-      filters: [
-        { name: "JSON Files", extensions: ["json"] },
-        { name: "All Files", extensions: ["*"] }
-      ]
-    });
-    if (!result.canceled && result.filePath) {
-      try {
-        await fs.writeFile(result.filePath, JSON.stringify(data, null, 2));
-        return result.filePath;
-      } catch (error) {
-        throw new Error(`Failed to save file: ${error}`);
-      }
-    }
-    return void 0;
-  });
-  electron.ipcMain.handle("dialog:message", async (event, options) => {
-    return await electron.dialog.showMessageBox(mainWindow2, options);
-  });
-}
-function registerListeners(mainWindow2) {
-  registerAppListeners();
-  registerWindowListeners(mainWindow2);
-  registerFileListeners(mainWindow2);
-}
-log.transports.file.level = "info";
-log.transports.console.level = "debug";
-updateElectronApp.updateElectronApp();
-if (process.platform === "win32") {
-  electron.app.setAppUserModelId("com.mcpjam.inspector");
-}
-let mainWindow = null;
-let server = null;
-let serverPort = 0;
-const isDev = process.env.NODE_ENV === "development";
-async function findAvailablePort(startPort = 3001) {
-  return new Promise((resolve, reject) => {
-    const net = require("net");
-    const server2 = net.createServer();
-    server2.listen(startPort, () => {
-      var _a;
-      const port = (_a = server2.address()) == null ? void 0 : _a.port;
-      server2.close(() => {
-        resolve(port);
-      });
-    });
-    server2.on("error", () => {
-      findAvailablePort(startPort + 1).then(resolve).catch(reject);
-    });
-  });
-}
-async function startHonoServer() {
-  try {
-    const port = await findAvailablePort(3001);
-    process.env.ELECTRON_APP = "true";
-    const honoApp = createHonoApp();
-    server = nodeServer.serve({
-      fetch: honoApp.fetch,
-      port,
-      hostname: "127.0.0.1"
-    });
-    log.info(`🚀 MCP Inspector Server started on port ${port}`);
-    return port;
-  } catch (error) {
-    log.error("Failed to start Hono server:", error);
-    throw error;
-  }
-}
-function createMainWindow(serverUrl) {
-  const window = new electron.BrowserWindow({
-    width: 1400,
-    height: 900,
-    minWidth: 800,
-    minHeight: 600,
-    icon: path.join(__dirname, "../assets/icon.png"),
-    // You can add an icon later
-    webPreferences: {
-      nodeIntegration: false,
-      contextIsolation: true,
-      enableRemoteModule: false,
-      preload: path.join(__dirname, "../preload/index.js")
-    },
-    titleBarStyle: process.platform === "darwin" ? "hiddenInset" : "default",
-    show: false
-    // Don't show until ready
-  });
-  registerListeners(window);
-  window.loadURL(serverUrl);
-  if (isDev) {
-    window.webContents.openDevTools();
-  }
-  window.once("ready-to-show", () => {
-    window.show();
-    if (isDev) {
-      window.webContents.openDevTools();
-    }
-  });
-  window.webContents.setWindowOpenHandler(({ url }) => {
-    electron.shell.openExternal(url);
-    return { action: "deny" };
-  });
-  window.on("closed", () => {
-    mainWindow = null;
-  });
-  return window;
-}
-function createAppMenu() {
-  const isMac = process.platform === "darwin";
-  const template = [
-    ...isMac ? [{
-      label: electron.app.getName(),
-      submenu: [
-        { role: "about" },
-        { type: "separator" },
-        { role: "services" },
-        { type: "separator" },
-        { role: "hide" },
-        { role: "hideothers" },
-        { role: "unhide" },
-        { type: "separator" },
-        { role: "quit" }
-      ]
-    }] : [],
-    {
-      label: "File",
-      submenu: [
-        isMac ? { role: "close" } : { role: "quit" }
-      ]
-    },
-    {
-      label: "Edit",
-      submenu: [
-        { role: "undo" },
-        { role: "redo" },
-        { type: "separator" },
-        { role: "cut" },
-        { role: "copy" },
-        { role: "paste" },
-        ...isMac ? [
-          { role: "pasteAndMatchStyle" },
-          { role: "delete" },
-          { role: "selectAll" },
-          { type: "separator" },
-          {
-            label: "Speech",
-            submenu: [
-              { role: "startSpeaking" },
-              { role: "stopSpeaking" }
-            ]
-          }
-        ] : [
-          { role: "delete" },
-          { type: "separator" },
-          { role: "selectAll" }
-        ]
-      ]
-    },
-    {
-      label: "View",
-      submenu: [
-        { role: "reload" },
-        { role: "forceReload" },
-        { role: "toggleDevTools" },
-        { type: "separator" },
-        { role: "resetZoom" },
-        { role: "zoomIn" },
-        { role: "zoomOut" },
-        { type: "separator" },
-        { role: "togglefullscreen" }
-      ]
-    },
-    {
-      label: "Window",
-      submenu: [
-        { role: "minimize" },
-        { role: "close" },
-        ...isMac ? [
-          { type: "separator" },
-          { role: "front" },
-          { type: "separator" },
-          { role: "window" }
-        ] : []
-      ]
-    }
-  ];
-  const menu = electron.Menu.buildFromTemplate(template);
-  electron.Menu.setApplicationMenu(menu);
-}
-electron.app.whenReady().then(async () => {
-  try {
-    serverPort = await startHonoServer();
-    const serverUrl = `http://127.0.0.1:${serverPort}`;
-    createAppMenu();
-    mainWindow = createMainWindow(serverUrl);
-    log.info("MCP Inspector Electron app ready");
-  } catch (error) {
-    log.error("Failed to initialize app:", error);
-    electron.app.quit();
-  }
-});
-electron.app.on("window-all-closed", () => {
-  var _a;
-  if (server) {
-    (_a = server.close) == null ? void 0 : _a.call(server);
-  }
-  if (process.platform !== "darwin") {
-    electron.app.quit();
-  }
-});
-electron.app.on("activate", async () => {
-  if (electron.BrowserWindow.getAllWindows().length === 0) {
-    if (serverPort > 0) {
-      const serverUrl = `http://127.0.0.1:${serverPort}`;
-      mainWindow = createMainWindow(serverUrl);
-    } else {
-      try {
-        serverPort = await startHonoServer();
-        const serverUrl = `http://127.0.0.1:${serverPort}`;
-        mainWindow = createMainWindow(serverUrl);
-      } catch (error) {
-        log.error("Failed to restart server:", error);
-      }
-    }
-  }
-});
-electron.app.on("web-contents-created", (_, contents) => {
-  contents.on("new-window", (navigationEvent, navigationUrl) => {
-    navigationEvent.preventDefault();
-    electron.shell.openExternal(navigationUrl);
-  });
-});
-electron.app.on("before-quit", () => {
-  var _a;
-  if (server) {
-    (_a = server.close) == null ? void 0 : _a.call(server);
-  }
-});
-const gotTheLock = electron.app.requestSingleInstanceLock();
-if (!gotTheLock) {
-  electron.app.quit();
-} else {
-  electron.app.on("second-instance", () => {
-    if (mainWindow) {
-      if (mainWindow.isMinimized()) mainWindow.restore();
-      mainWindow.focus();
-    }
-  });
-}