@mcpjam/inspector 0.8.1 → 0.9.0

package/dist/main/main.cjs

@@ -0,0 +1,1330 @@
+"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 registerMcpListeners(mainWindow2) {
+  electron.ipcMain.handle("mcp:connect", async (event, config) => {
+    console.log("MCP connect requested:", config);
+    return { success: true, id: "temp-id" };
+  });
+  electron.ipcMain.handle("mcp:disconnect", async (event, id) => {
+    console.log("MCP disconnect requested:", id);
+    return { success: true };
+  });
+  electron.ipcMain.handle("mcp:list-servers", async () => {
+    console.log("MCP list servers requested");
+    return [];
+  });
+}
+function registerListeners(mainWindow2) {
+  registerAppListeners();
+  registerWindowListeners(mainWindow2);
+  registerFileListeners(mainWindow2);
+  registerMcpListeners();
+}
+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();
+    }
+  });
+}