@mcpjam/inspector 0.9.23 → 0.9.25

package/dist/main/main.cjs

@@ -1,1818 +0,0 @@
-"use strict";
-var _a;
-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 zodToJsonSchema = require("zod-to-json-schema");
-const util = require("util");
-const agent = require("@mastra/core/agent");
-const anthropic = require("@ai-sdk/anthropic");
-const openai = require("@ai-sdk/openai");
-const ollamaAiProvider = require("ollama-ai-provider");
-require("clsx");
-const fs = require("fs/promises");
-const mcp$1 = require("@mastra/mcp");
-const log = require("electron-log");
-const updateElectronApp = require("update-electron-app");
-const connect = new hono.Hono();
-connect.post("/", async (c) => {
-  try {
-    const { serverConfig, serverId } = await c.req.json();
-    if (!serverConfig) {
-      return c.json(
-        {
-          success: false,
-          error: "serverConfig is required"
-        },
-        400
-      );
-    }
-    if (!serverId) {
-      return c.json(
-        {
-          success: false,
-          error: "serverId is required"
-        },
-        400
-      );
-    }
-    const mcpClientManager = c.mcpJamClientManager;
-    try {
-      await mcpClientManager.connectToServer(serverId, serverConfig);
-      const status = mcpClientManager.getConnectionStatus(serverId);
-      if (status === "connected") {
-        return c.json({
-          success: true,
-          status: "connected"
-        });
-      } else {
-        return c.json(
-          {
-            success: false,
-            error: "Connection failed",
-            status
-          },
-          500
-        );
-      }
-    } 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 servers = new hono.Hono();
-servers.get("/", async (c) => {
-  try {
-    const mcpJamClientManager = c.mcpJamClientManager;
-    const connectedServers = mcpJamClientManager.getConnectedServers();
-    const serverList = Object.entries(connectedServers).map(
-      ([serverId, serverInfo]) => ({
-        id: serverId,
-        name: serverId,
-        status: serverInfo.status,
-        config: serverInfo.config
-      })
-    );
-    return c.json({
-      success: true,
-      servers: serverList
-    });
-  } catch (error) {
-    console.error("Error listing servers:", error);
-    return c.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
-      500
-    );
-  }
-});
-servers.get("/status/:serverId", async (c) => {
-  try {
-    const serverId = c.req.param("serverId");
-    const mcpJamClientManager = c.mcpJamClientManager;
-    const status = mcpJamClientManager.getConnectionStatus(serverId);
-    return c.json({
-      success: true,
-      serverId,
-      status
-    });
-  } catch (error) {
-    console.error("Error getting server status:", error);
-    return c.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
-      500
-    );
-  }
-});
-servers.delete("/:serverId", async (c) => {
-  try {
-    const serverId = c.req.param("serverId");
-    const mcpJamClientManager = c.mcpJamClientManager;
-    await mcpJamClientManager.disconnectFromServer(serverId);
-    return c.json({
-      success: true,
-      message: `Disconnected from server: ${serverId}`
-    });
-  } catch (error) {
-    console.error("Error disconnecting server:", error);
-    return c.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
-      500
-    );
-  }
-});
-servers.post("/reconnect", async (c) => {
-  try {
-    const { serverId, serverConfig } = await c.req.json();
-    if (!serverId || !serverConfig) {
-      return c.json(
-        {
-          success: false,
-          error: "serverId and serverConfig are required"
-        },
-        400
-      );
-    }
-    const mcpJamClientManager = c.mcpJamClientManager;
-    await mcpJamClientManager.disconnectFromServer(serverId);
-    await mcpJamClientManager.connectToServer(serverId, serverConfig);
-    const status = mcpJamClientManager.getConnectionStatus(serverId);
-    return c.json({
-      success: true,
-      serverId,
-      status,
-      message: `Reconnected to server: ${serverId}`
-    });
-  } catch (error) {
-    console.error("Error reconnecting server:", error);
-    return c.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
-      500
-    );
-  }
-});
-const tools = new hono.Hono();
-const pendingElicitations$1 = /* @__PURE__ */ new Map();
-tools.post("/", async (c) => {
-  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 mcpJamClientManager = c.mcpJamClientManager;
-      const success = mcpJamClientManager.respondToElicitation(
-        requestId,
-        response
-      );
-      if (!success) {
-        const pending = pendingElicitations$1.get(requestId);
-        if (pending) {
-          pending.resolve(response);
-          pendingElicitations$1.delete(requestId);
-          return c.json({ success: true });
-        }
-        return c.json(
-          {
-            success: false,
-            error: "No pending elicitation found for this requestId"
-          },
-          404
-        );
-      }
-      return c.json({ success: true });
-    }
-    const encoder = new util.TextEncoder();
-    const readableStream = new ReadableStream({
-      async start(controller) {
-        try {
-          if (!serverConfig) {
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({ type: "tool_error", error: "serverConfig is required" })}
-
-`
-              )
-            );
-            controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-            controller.close();
-            return;
-          }
-          const mcpJamClientManager = c.mcpJamClientManager;
-          const serverId = serverConfig.name || serverConfig.id || "server";
-          await mcpJamClientManager.connectToServer(serverId, serverConfig);
-          mcpJamClientManager.setElicitationCallback(async (request) => {
-            const { requestId: requestId2, message, schema } = request;
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "elicitation_request",
-                  requestId: requestId2,
-                  message,
-                  schema,
-                  toolName: toolName || "unknown",
-                  timestamp: /* @__PURE__ */ new Date()
-                })}
-
-`
-              )
-            );
-            return new Promise((resolve, reject) => {
-              pendingElicitations$1.set(requestId2, {
-                resolve: (response2) => {
-                  resolve(response2);
-                  pendingElicitations$1.delete(requestId2);
-                },
-                reject: (error) => {
-                  reject(error);
-                  pendingElicitations$1.delete(requestId2);
-                }
-              });
-              setTimeout(() => {
-                if (pendingElicitations$1.has(requestId2)) {
-                  pendingElicitations$1.delete(requestId2);
-                  reject(new Error("Elicitation timeout"));
-                }
-              }, 3e5);
-            });
-          });
-          if (action === "list") {
-            try {
-              const flattenedTools = await mcpJamClientManager.getToolsetsForServer(serverId);
-              const toolsWithJsonSchema = {};
-              for (const [name, tool] of Object.entries(flattenedTools)) {
-                let inputSchema = tool.inputSchema;
-                try {
-                  inputSchema = zodToJsonSchema.zodToJsonSchema(inputSchema);
-                } catch {
-                }
-                toolsWithJsonSchema[name] = {
-                  name,
-                  description: tool.description,
-                  inputSchema,
-                  outputSchema: tool.outputSchema
-                };
-              }
-              controller.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({ type: "tools_list", tools: toolsWithJsonSchema })}
-
-`
-                )
-              );
-              controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-              controller.close();
-              return;
-            } catch (err) {
-              controller.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({ type: "tool_error", error: err instanceof Error ? err.message : String(err) })}
-
-`
-                )
-              );
-              controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-              controller.close();
-              return;
-            }
-          }
-          if (action === "execute") {
-            if (!toolName) {
-              controller.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({ type: "tool_error", error: "Tool name is required for execution" })}
-
-`
-                )
-              );
-              controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-              controller.close();
-              return;
-            }
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({ type: "tool_executing", toolName, parameters: parameters || {}, message: "Executing tool..." })}
-
-`
-              )
-            );
-            const exec = await mcpJamClientManager.executeToolDirect(
-              toolName,
-              parameters || {}
-            );
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({ type: "tool_result", toolName, result: exec.result })}
-
-`
-              )
-            );
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({ type: "elicitation_complete", toolName })}
-
-`
-              )
-            );
-            controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-            controller.close();
-            return;
-          }
-        } catch (err) {
-          controller.enqueue(
-            encoder.encode(
-              `data: ${JSON.stringify({ type: "tool_error", error: err instanceof Error ? err.message : String(err) })}
-
-`
-            )
-          );
-          controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-          controller.close();
-        } finally {
-          const mcpJamClientManager = c.mcpJamClientManager;
-          if (mcpJamClientManager) {
-            mcpJamClientManager.clearElicitationCallback();
-          }
-        }
-      }
-    });
-    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";
-    return c.json(
-      {
-        success: false,
-        error: errorMsg
-      },
-      500
-    );
-  }
-});
-const resources = new hono.Hono();
-resources.post("/list", async (c) => {
-  try {
-    const { serverId } = await c.req.json();
-    if (!serverId) {
-      return c.json({ success: false, error: "serverId is required" }, 400);
-    }
-    const mcpClientManager = c.mcpJamClientManager;
-    const serverResources = mcpClientManager.getResourcesForServer(serverId);
-    return c.json({ resources: { [serverId]: serverResources } });
-  } 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 { serverId, uri } = await c.req.json();
-    if (!serverId) {
-      return c.json({ success: false, error: "serverId is required" }, 400);
-    }
-    if (!uri) {
-      return c.json(
-        {
-          success: false,
-          error: "Resource URI is required"
-        },
-        400
-      );
-    }
-    const mcpClientManager = c.mcpJamClientManager;
-    const content = await mcpClientManager.getResource(uri, serverId);
-    return c.json({ content });
-  } 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 { serverId } = await c.req.json();
-    if (!serverId) {
-      return c.json({ success: false, error: "serverId is required" }, 400);
-    }
-    const mcpJamClientManager = c.mcpJamClientManager;
-    const serverPrompts = mcpJamClientManager.getPromptsForServer(serverId);
-    return c.json({ prompts: { [serverId]: serverPrompts } });
-  } 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 { serverId, name, args } = await c.req.json();
-    if (!serverId) {
-      return c.json({ success: false, error: "serverId is required" }, 400);
-    }
-    if (!name) {
-      return c.json(
-        {
-          success: false,
-          error: "Prompt name is required"
-        },
-        400
-      );
-    }
-    const mcpJamClientManager = c.mcpJamClientManager;
-    const content = await mcpJamClientManager.getPrompt(
-      name,
-      serverId,
-      args || {}
-    );
-    return c.json({ content });
-  } catch (error) {
-    console.error("Error getting prompt:", error);
-    return c.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
-      500
-    );
-  }
-});
-function getDefaultTemperatureByProvider(provider) {
-  switch (provider) {
-    case "openai":
-      return 1;
-    case "anthropic":
-      return 0;
-    default:
-      return 0;
-  }
-}
-const DEBUG_ENABLED = process.env.MCP_DEBUG !== "false";
-const ELICITATION_TIMEOUT = 3e5;
-const MAX_AGENT_STEPS = 10;
-const dbg = (...args) => {
-  if (DEBUG_ENABLED) console.log("[mcp/chat]", ...args);
-};
-try {
-  (_a = process.setMaxListeners) == null ? void 0 : _a.call(process, 50);
-} catch {
-}
-const pendingElicitations = /* @__PURE__ */ new Map();
-const chat = new hono.Hono();
-const createLlmModel = (modelDefinition, apiKey, ollamaBaseUrl) => {
-  if (!(modelDefinition == null ? void 0 : modelDefinition.id) || !(modelDefinition == null ? void 0 : 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 "deepseek":
-      return openai.createOpenAI({ apiKey, baseURL: "https://api.deepseek.com/v1" })(
-        modelDefinition.id
-      );
-    case "ollama":
-      const baseUrl = ollamaBaseUrl || "http://localhost:11434";
-      return ollamaAiProvider.createOllama({
-        baseURL: `${baseUrl}`
-      })(modelDefinition.id, {
-        simulateStreaming: true
-      });
-    default:
-      throw new Error(
-        `Unsupported provider: ${modelDefinition.provider} for model: ${modelDefinition.id}`
-      );
-  }
-};
-const wrapToolsWithStreaming = (tools2, streamingContext) => {
-  const wrappedTools = {};
-  for (const [name, tool] of Object.entries(tools2)) {
-    wrappedTools[name] = {
-      ...tool,
-      execute: async (params) => {
-        const currentToolCallId = ++streamingContext.toolCallId;
-        const startedAt = Date.now();
-        if (streamingContext.controller && streamingContext.encoder) {
-          streamingContext.controller.enqueue(
-            streamingContext.encoder.encode(
-              `data: ${JSON.stringify({
-                type: "tool_call",
-                toolCall: {
-                  id: currentToolCallId,
-                  name,
-                  parameters: params,
-                  timestamp: /* @__PURE__ */ new Date(),
-                  status: "executing"
-                }
-              })}
-
-`
-            )
-          );
-        }
-        dbg("Tool executing", { name, currentToolCallId, params });
-        try {
-          const result = await tool.execute(params);
-          dbg("Tool result", {
-            name,
-            currentToolCallId,
-            ms: Date.now() - startedAt
-          });
-          if (streamingContext.controller && streamingContext.encoder) {
-            streamingContext.controller.enqueue(
-              streamingContext.encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "tool_result",
-                  toolResult: {
-                    id: currentToolCallId,
-                    toolCallId: currentToolCallId,
-                    result,
-                    timestamp: /* @__PURE__ */ new Date()
-                  }
-                })}
-
-`
-              )
-            );
-          }
-          return result;
-        } catch (error) {
-          dbg("Tool error", {
-            name,
-            currentToolCallId,
-            error: error instanceof Error ? error.message : String(error)
-          });
-          if (streamingContext.controller && streamingContext.encoder) {
-            streamingContext.controller.enqueue(
-              streamingContext.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;
-        }
-      }
-    };
-  }
-  return wrappedTools;
-};
-const handleAgentStepFinish = (streamingContext, text, toolCalls, toolResults) => {
-  try {
-    if (toolCalls && Array.isArray(toolCalls)) {
-      for (const call of toolCalls) {
-        const currentToolCallId = ++streamingContext.toolCallId;
-        streamingContext.lastEmittedToolCallId = currentToolCallId;
-        if (streamingContext.controller && streamingContext.encoder) {
-          streamingContext.controller.enqueue(
-            streamingContext.encoder.encode(
-              `data: ${JSON.stringify({
-                type: "tool_call",
-                toolCall: {
-                  id: currentToolCallId,
-                  name: call.name || call.toolName,
-                  parameters: call.params || call.args || {},
-                  timestamp: /* @__PURE__ */ new Date(),
-                  status: "executing"
-                }
-              })}
-
-`
-            )
-          );
-        }
-      }
-    }
-    if (toolResults && Array.isArray(toolResults)) {
-      for (const result of toolResults) {
-        const currentToolCallId = streamingContext.lastEmittedToolCallId != null ? streamingContext.lastEmittedToolCallId : ++streamingContext.toolCallId;
-        if (streamingContext.controller && streamingContext.encoder) {
-          streamingContext.controller.enqueue(
-            streamingContext.encoder.encode(
-              `data: ${JSON.stringify({
-                type: "tool_result",
-                toolResult: {
-                  id: currentToolCallId,
-                  toolCallId: currentToolCallId,
-                  result: result.result,
-                  error: result.error,
-                  timestamp: /* @__PURE__ */ new Date()
-                }
-              })}
-
-`
-            )
-          );
-        }
-      }
-    }
-    streamingContext.stepIndex = (streamingContext.stepIndex || 0) + 1;
-    if (streamingContext.controller && streamingContext.encoder) {
-      streamingContext.controller.enqueue(
-        streamingContext.encoder.encode(
-          `data: ${JSON.stringify({
-            type: "trace_step",
-            step: streamingContext.stepIndex,
-            text,
-            toolCalls: (toolCalls || []).map((c) => ({
-              name: c.name || c.toolName,
-              params: c.params || c.args || {}
-            })),
-            toolResults: (toolResults || []).map((r) => ({
-              result: r.result,
-              error: r.error
-            })),
-            timestamp: /* @__PURE__ */ new Date()
-          })}
-
-`
-        )
-      );
-    }
-  } catch (err) {
-    dbg("onStepFinish error", err);
-  }
-};
-const streamAgentResponse = async (streamingContext, stream) => {
-  let hasContent = false;
-  let chunkCount = 0;
-  for await (const chunk of stream.textStream) {
-    if (chunk && chunk.trim()) {
-      hasContent = true;
-      chunkCount++;
-      streamingContext.controller.enqueue(
-        streamingContext.encoder.encode(
-          `data: ${JSON.stringify({ type: "text", content: chunk })}
-
-`
-        )
-      );
-    }
-  }
-  dbg("Streaming finished", { hasContent, chunkCount });
-  return { hasContent, chunkCount };
-};
-const fallbackToCompletion = async (agent2, messages, streamingContext, provider) => {
-  try {
-    const result = await agent2.generate(messages, {
-      temperature: getDefaultTemperatureByProvider(provider)
-    });
-    if (result.text && result.text.trim()) {
-      streamingContext.controller.enqueue(
-        streamingContext.encoder.encode(
-          `data: ${JSON.stringify({
-            type: "text",
-            content: result.text
-          })}
-
-`
-        )
-      );
-    }
-  } catch (fallbackErr) {
-    streamingContext.controller.enqueue(
-      streamingContext.encoder.encode(
-        `data: ${JSON.stringify({
-          type: "text",
-          content: "Failed to generate response. Please try again. ",
-          error: fallbackErr instanceof Error ? fallbackErr.message : "Unknown error"
-        })}
-
-`
-      )
-    );
-  }
-};
-const createStreamingResponse = async (agent2, messages, toolsets, streamingContext, provider) => {
-  const stream = await agent2.stream(messages, {
-    maxSteps: MAX_AGENT_STEPS,
-    temperature: getDefaultTemperatureByProvider(provider),
-    toolsets,
-    onStepFinish: ({ text, toolCalls, toolResults }) => {
-      handleAgentStepFinish(streamingContext, text, toolCalls, toolResults);
-    }
-  });
-  const { hasContent } = await streamAgentResponse(streamingContext, stream);
-  if (!hasContent) {
-    dbg("No content from textStream; falling back to completion");
-    await fallbackToCompletion(agent2, messages, streamingContext, provider);
-  }
-  streamingContext.controller.enqueue(
-    streamingContext.encoder.encode(
-      `data: ${JSON.stringify({
-        type: "elicitation_complete"
-      })}
-
-`
-    )
-  );
-  streamingContext.controller.enqueue(
-    streamingContext.encoder.encode(`data: [DONE]
-
-`)
-  );
-};
-chat.post("/", async (c) => {
-  const mcpClientManager = c.mcpJamClientManager;
-  try {
-    const requestData = await c.req.json();
-    const {
-      serverConfigs,
-      model,
-      provider,
-      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 == null ? void 0 : 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) {
-      return c.json(
-        {
-          success: false,
-          error: "No server configs provided"
-        },
-        400
-      );
-    }
-    const serverErrors = {};
-    const connectedServers = [];
-    for (const [serverName, serverConfig] of Object.entries(serverConfigs)) {
-      try {
-        await mcpClientManager.connectToServer(serverName, serverConfig);
-        connectedServers.push(serverName);
-        dbg("Connected to server", { serverName });
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        serverErrors[serverName] = errorMessage;
-        dbg("Failed to connect to server", { serverName, error: errorMessage });
-      }
-    }
-    if (connectedServers.length === 0) {
-      return c.json(
-        {
-          success: false,
-          error: "Failed to connect to any servers",
-          details: serverErrors
-        },
-        400
-      );
-    }
-    if (Object.keys(serverErrors).length > 0) {
-      dbg("Some servers failed to connect", {
-        connectedServers,
-        failedServers: Object.keys(serverErrors),
-        errors: serverErrors
-      });
-    }
-    const llmModel = createLlmModel(model, apiKey, ollamaBaseUrl);
-    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: void 0
-      // Start without tools, add them in streaming context
-    });
-    const formattedMessages = messages.map((msg) => ({
-      role: msg.role,
-      content: msg.content
-    }));
-    const allTools = mcpClientManager.getAvailableTools();
-    const toolsByServer = {};
-    for (const tool of allTools) {
-      if (!toolsByServer[tool.serverId]) {
-        toolsByServer[tool.serverId] = {};
-      }
-      toolsByServer[tool.serverId][tool.name] = {
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-        execute: async (params) => {
-          return await mcpClientManager.executeToolDirect(
-            `${tool.serverId}:${tool.name}`,
-            params
-          );
-        }
-      };
-    }
-    dbg("Streaming start", {
-      connectedServers,
-      toolCount: allTools.length,
-      messageCount: formattedMessages.length
-    });
-    const encoder = new util.TextEncoder();
-    const readableStream = new ReadableStream({
-      async start(controller) {
-        const streamingContext = {
-          controller,
-          encoder,
-          toolCallId: 0,
-          lastEmittedToolCallId: null,
-          stepIndex: 0
-        };
-        const flattenedTools = {};
-        Object.values(toolsByServer).forEach((serverTools) => {
-          Object.assign(flattenedTools, serverTools);
-        });
-        const streamingWrappedTools = wrapToolsWithStreaming(
-          flattenedTools,
-          streamingContext
-        );
-        const streamingAgent = new agent.Agent({
-          name: agent$1.name,
-          instructions: agent$1.instructions,
-          model: agent$1.model,
-          tools: Object.keys(streamingWrappedTools).length > 0 ? streamingWrappedTools : void 0
-        });
-        mcpClientManager.setElicitationCallback(async (request) => {
-          const elicitationRequest = {
-            message: request.message,
-            requestedSchema: request.schema
-          };
-          if (streamingContext.controller && streamingContext.encoder) {
-            streamingContext.controller.enqueue(
-              streamingContext.encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "elicitation_request",
-                  requestId: request.requestId,
-                  message: elicitationRequest.message,
-                  schema: elicitationRequest.requestedSchema,
-                  timestamp: /* @__PURE__ */ new Date()
-                })}
-
-`
-              )
-            );
-          }
-          return new Promise((resolve, reject) => {
-            pendingElicitations.set(request.requestId, { resolve, reject });
-            setTimeout(() => {
-              if (pendingElicitations.has(request.requestId)) {
-                pendingElicitations.delete(request.requestId);
-                reject(new Error("Elicitation timeout"));
-              }
-            }, ELICITATION_TIMEOUT);
-          });
-        });
-        try {
-          await createStreamingResponse(
-            streamingAgent,
-            formattedMessages,
-            toolsByServer,
-            streamingContext,
-            provider
-          );
-        } catch (error) {
-          controller.enqueue(
-            encoder.encode(
-              `data: ${JSON.stringify({
-                type: "error",
-                error: error instanceof Error ? error.message : "Unknown error"
-              })}
-
-`
-            )
-          );
-        } finally {
-          mcpClientManager.clearElicitationCallback();
-          controller.close();
-        }
-      }
-    });
-    return new Response(readableStream, {
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
-      }
-    });
-  } catch (error) {
-    console.error("[mcp/chat] Error in chat API:", error);
-    mcpClientManager.clearElicitationCallback();
-    return c.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
-      500
-    );
-  }
-});
-function validateServerConfig(serverConfig) {
-  var _a2, _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") {
-        const parsed = new URL(config.url);
-        parsed.search = "";
-        parsed.hash = "";
-        config.url = parsed;
-      } else if (typeof config.url === "object" && !config.url.href) {
-        return {
-          success: false,
-          error: {
-            message: "Invalid URL configuration",
-            status: 400
-          }
-        };
-      }
-      if ((_a2 = config.oauth) == null ? void 0 : _a2.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 _a3;
-            const headers = new Headers((init == null ? void 0 : init.headers) || {});
-            headers.set(
-              "Authorization",
-              `Bearer ${config.oauth.access_token}`
-            );
-            if ((_a3 = config.requestInit) == null ? void 0 : _a3.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 generateUniqueServerID(serverName) {
-  const normalizedBase = normalizeServerConfigName(serverName);
-  const timestamp = Date.now().toString(36);
-  const random = Math.random().toString(36).substring(2, 8);
-  return `${normalizedBase}_${timestamp}_${random}`;
-}
-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 serverNameMapping = {};
-  const errors = {};
-  let hasErrors = false;
-  for (const [serverName, serverConfig] of Object.entries(serverConfigs)) {
-    const validationResult = validateServerConfig(serverConfig);
-    if (validationResult.success && validationResult.config) {
-      const serverID = generateUniqueServerID(serverName);
-      validConfigs[serverID] = validationResult.config;
-      serverNameMapping[serverID] = serverName;
-    } else {
-      hasErrors = true;
-      let errorMessage = "Configuration validation failed";
-      if (validationResult.error) {
-        errorMessage = validationResult.error.message;
-      }
-      errors[serverName] = errorMessage;
-    }
-  }
-  if (!hasErrors) {
-    return {
-      success: true,
-      validConfigs,
-      serverNameMapping
-    };
-  }
-  if (Object.keys(validConfigs).length > 0) {
-    return {
-      success: false,
-      validConfigs,
-      serverNameMapping,
-      errors
-    };
-  }
-  return {
-    success: false,
-    errors,
-    error: {
-      message: "All server configurations failed validation",
-      status: 400
-    }
-  };
-};
-function createMCPClientWithMultipleConnections(serverConfigs) {
-  const originalMCPClient = new mcp$1.MCPClient({
-    id: `chat-${Date.now()}`,
-    servers: serverConfigs
-  });
-  const originalGetTools = originalMCPClient.getTools.bind(originalMCPClient);
-  originalMCPClient.getTools = async () => {
-    const tools2 = await originalGetTools();
-    const fixedTools = {};
-    for (const [toolName, toolConfig] of Object.entries(tools2)) {
-      const parts = toolName.split("_");
-      if (parts.length >= 3 && parts[0] === parts[1]) {
-        const fixedName = parts.slice(1).join("_");
-        fixedTools[fixedName] = toolConfig;
-      } else {
-        fixedTools[toolName] = toolConfig;
-      }
-    }
-    return fixedTools;
-  };
-  return originalMCPClient;
-}
-function normalizeServerConfigName(serverName) {
-  return serverName.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
-}
-const tests = new hono.Hono();
-tests.post("/generate", async (c) => {
-  try {
-    const body = await c.req.json();
-    const test = body == null ? void 0 : body.test;
-    const servers2 = body == null ? void 0 : body.servers;
-    const model = body == null ? void 0 : body.model;
-    if (!(test == null ? void 0 : test.id) || !(test == null ? void 0 : test.prompt) || !servers2 || Object.keys(servers2).length === 0) {
-      return c.json(
-        { success: false, error: "Missing test, servers, or prompt" },
-        400
-      );
-    }
-    const safeName = String(test.title || test.id).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
-    const filename = `@TestAgent_${safeName || test.id}.ts`;
-    const fileContents = `import { Agent } from "@mastra/core/agent";
-import { MCPClient } from "@mastra/mcp";
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createOpenAI } from "@ai-sdk/openai";
-import { createOllama } from "ollama-ai-provider";
-
-const servers = ${JSON.stringify(servers2, null, 2)} as const;
-
-function createModel() {
-  const def = ${JSON.stringify(model || null)} as any;
-  if (!def) throw new Error("Model not provided by UI when generating test agent");
-  switch (def.provider) {
-    case "anthropic": return createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY! })(def.id);
-    case "openai": return createOpenAI({ apiKey: process.env.OPENAI_API_KEY! })(def.id);
-    case "deepseek": return createOpenAI({ apiKey: process.env.DEEPSEEK_API_KEY!, baseURL: "https://api.deepseek.com/v1" })(def.id);
-    case "ollama": return createOllama({ baseURL: process.env.OLLAMA_BASE_URL || "http://localhost:11434" })(def.id, { simulateStreaming: true });
-    default: throw new Error("Unsupported provider: " + def.provider);
-  }
-}
-
-export const createTestAgent = async () => {
-  const mcp = new MCPClient({ servers });
-  const toolsets = await mcp.getToolsets();
-  return new Agent({
-    name: ${JSON.stringify(test.title || "Test Agent")},
-    instructions: ${JSON.stringify(test.prompt)},
-    model: createModel(),
-    tools: undefined,
-    defaultGenerateOptions: { toolChoice: "auto" }
-  });
-};
-`;
-    const targetPath = path.join(process.cwd(), "server", "agents", filename);
-    await fs.mkdir(path.dirname(targetPath), { recursive: true });
-    await fs.writeFile(targetPath, fileContents, "utf8");
-    return c.json({ success: true, file: `server/agents/${filename}` });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : "Unknown error";
-    return c.json({ success: false, error: msg }, 500);
-  }
-});
-tests.post("/run-all", async (c) => {
-  const encoder = new TextEncoder();
-  try {
-    let createModel = function(model) {
-      switch (model.provider) {
-        case "anthropic":
-          return anthropic.createAnthropic({
-            apiKey: (providerApiKeys == null ? void 0 : providerApiKeys.anthropic) || process.env.ANTHROPIC_API_KEY || ""
-          })(model.id);
-        case "openai":
-          return openai.createOpenAI({
-            apiKey: (providerApiKeys == null ? void 0 : providerApiKeys.openai) || process.env.OPENAI_API_KEY || ""
-          })(model.id);
-        case "deepseek":
-          return openai.createOpenAI({
-            apiKey: (providerApiKeys == null ? void 0 : providerApiKeys.deepseek) || process.env.DEEPSEEK_API_KEY || "",
-            baseURL: "https://api.deepseek.com/v1"
-          })(model.id);
-        case "ollama":
-          return ollamaAiProvider.createOllama({
-            baseURL: ollamaBaseUrl || process.env.OLLAMA_BASE_URL || "http://localhost:11434"
-          })(model.id, { simulateStreaming: true });
-        default:
-          throw new Error(`Unsupported provider: ${model.provider}`);
-      }
-    };
-    const body = await c.req.json();
-    const testsInput = (body == null ? void 0 : body.tests) || [];
-    const allServers = (body == null ? void 0 : body.allServers) || {};
-    const providerApiKeys = (body == null ? void 0 : body.providerApiKeys) || {};
-    const ollamaBaseUrl = body == null ? void 0 : body.ollamaBaseUrl;
-    const maxConcurrency = Math.max(
-      1,
-      Math.min(8, (body == null ? void 0 : body.concurrency) ?? 5)
-    );
-    if (!Array.isArray(testsInput) || testsInput.length === 0) {
-      return c.json({ success: false, error: "No tests provided" }, 400);
-    }
-    const readableStream = new ReadableStream({
-      async start(controller) {
-        let active = 0;
-        let index = 0;
-        let failed = false;
-        const runNext = async () => {
-          if (index >= testsInput.length) {
-            if (active === 0) {
-              controller.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({ type: "run_complete", passed: !failed })}
-
-`
-                )
-              );
-              controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-              controller.close();
-            }
-            return;
-          }
-          const test = testsInput[index++];
-          active++;
-          (async () => {
-            const calledTools = /* @__PURE__ */ new Set();
-            const expectedSet = new Set(test.expectedTools || []);
-            let step = 0;
-            let client = null;
-            try {
-              let serverConfigs = {};
-              if (test.selectedServers && test.selectedServers.length > 0) {
-                for (const name of test.selectedServers) {
-                  if (allServers[name]) serverConfigs[name] = allServers[name];
-                }
-              } else {
-                for (const [name, cfg] of Object.entries(allServers)) {
-                  serverConfigs[name] = cfg;
-                }
-              }
-              const validation = validateMultipleServerConfigs(serverConfigs);
-              let finalServers = {};
-              if (validation.success && validation.validConfigs) {
-                finalServers = validation.validConfigs;
-              } else if (validation.validConfigs && Object.keys(validation.validConfigs).length > 0) {
-                finalServers = validation.validConfigs;
-              } else {
-                throw new Error("No valid MCP server configs for test");
-              }
-              client = createMCPClientWithMultipleConnections(finalServers);
-              const model = createModel(test.model);
-              const agent$1 = new agent.Agent({
-                name: `TestAgent-${test.id}`,
-                instructions: "You are a helpful assistant with access to MCP tools",
-                model
-              });
-              const toolsets = await client.getToolsets();
-              const stream = await agent$1.stream(
-                [{ role: "user", content: test.prompt || "" }],
-                {
-                  maxSteps: 10,
-                  toolsets,
-                  onStepFinish: ({ text, toolCalls, toolResults }) => {
-                    step += 1;
-                    (toolCalls || []).forEach((c2) => {
-                      const toolName = (c2 == null ? void 0 : c2.name) || (c2 == null ? void 0 : c2.toolName);
-                      if (toolName) {
-                        calledTools.add(toolName);
-                      }
-                    });
-                    controller.enqueue(
-                      encoder.encode(
-                        `data: ${JSON.stringify({
-                          type: "trace_step",
-                          testId: test.id,
-                          step,
-                          text,
-                          toolCalls,
-                          toolResults
-                        })}
-
-`
-                      )
-                    );
-                  }
-                }
-              );
-              for await (const _ of stream.textStream) {
-              }
-              const called = Array.from(calledTools);
-              const missing = Array.from(expectedSet).filter(
-                (t) => !calledTools.has(t)
-              );
-              const unexpected = called.filter((t) => !expectedSet.has(t));
-              const passed = missing.length === 0 && unexpected.length === 0;
-              if (!passed) failed = true;
-              controller.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({ type: "result", testId: test.id, passed, calledTools: called, missingTools: missing, unexpectedTools: unexpected })}
-
-`
-                )
-              );
-            } catch (err) {
-              failed = true;
-              controller.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({ type: "result", testId: test.id, passed: false, error: err == null ? void 0 : err.message })}
-
-`
-                )
-              );
-            } finally {
-              try {
-                await (client == null ? void 0 : client.disconnect());
-              } catch {
-              }
-              active--;
-              runNext();
-            }
-          })();
-        };
-        for (let i = 0; i < Math.min(maxConcurrency, testsInput.length); i++) {
-          runNext();
-        }
-      }
-    });
-    return new Response(readableStream, {
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
-      }
-    });
-  } catch (err) {
-    return c.json(
-      { success: false, error: (err == null ? void 0 : err.message) || "Unknown error" },
-      500
-    );
-  }
-});
-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("/servers", servers);
-mcp.route("/tools", tools);
-mcp.route("/tests", tests);
-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: "MCPJam 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 _a2;
-      const port = (_a2 = server2.address()) == null ? void 0 : _a2.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(`🚀 MCPJam 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("MCPJam Electron app ready");
-  } catch (error) {
-    log.error("Failed to initialize app:", error);
-    electron.app.quit();
-  }
-});
-electron.app.on("window-all-closed", () => {
-  var _a2;
-  if (server) {
-    (_a2 = server.close) == null ? void 0 : _a2.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 _a2;
-  if (server) {
-    (_a2 = server.close) == null ? void 0 : _a2.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();
-    }
-  });
-}