dev3000 0.0.92 → 0.0.94

package/mcp-server/.next/server/server-reference-manifest.js

@@ -1 +1 @@
-self.__RSC_SERVER_MANIFEST="{\n  \"node\": {},\n  \"edge\": {},\n  \"encryptionKey\": \"lZgibe2ziYqyEAkZ7RFH62f938aB/wxVlceTcZMnbR8=\"\n}"
+self.__RSC_SERVER_MANIFEST="{\n  \"node\": {},\n  \"edge\": {},\n  \"encryptionKey\": \"Az3Ay/ZpgjzPNsVoQzRDLlh6S8/dSjBuLozeWfes2Dc=\"\n}"

package/mcp-server/.next/server/server-reference-manifest.json

@@ -1,5 +1,5 @@
 {
   "node": {},
   "edge": {},
-  "encryptionKey": "lZgibe2ziYqyEAkZ7RFH62f938aB/wxVlceTcZMnbR8="
+  "encryptionKey": "Az3Ay/ZpgjzPNsVoQzRDLlh6S8/dSjBuLozeWfes2Dc="
 }

package/mcp-server/app/mcp/client-manager.ts

@@ -32,6 +32,8 @@ export class MCPClientManager {
   private tools: Map<string, Tool[]> = new Map()
   private reconnectTimers: Map<string, NodeJS.Timeout> = new Map()
   private lastConfigs: Map<string, MCPClientConfig> = new Map()
+  private toolDiscoveryListeners: Array<() => void> = []
+  private toolUpdateSubscribers: Array<(info: { mcpName: string; tools: Tool[] }) => void> = []
 
   /**
    * Initialize MCP clients for available downstream servers
@@ -118,26 +120,23 @@ export class MCPClientManager {
 
     // Discover available tools (non-fatal - connection already succeeded)
     try {
-      const toolsResult = await client.request(
-        {
-          method: "tools/list",
-          params: {}
-        },
-        undefined as any // Type inference will work at runtime
-      )
-
-      if (toolsResult && "tools" in toolsResult) {
-        this.tools.set(config.name, toolsResult.tools as Tool[])
-        console.log(`[MCP Orchestrator] Discovered ${toolsResult.tools.length} tools from ${config.name}`)
+      const toolsResult = await client.listTools()
+      const discoveredTools = Array.isArray(toolsResult?.tools) ? (toolsResult.tools as Tool[]) : []
+
+      this.tools.set(config.name, discoveredTools)
+
+      if (discoveredTools.length > 0) {
+        console.log(`[MCP Orchestrator] Discovered ${discoveredTools.length} tools from ${config.name}`)
+        this.notifyToolDiscovery()
       } else {
-        // Set empty array if no tools found
-        this.tools.set(config.name, [])
         console.log(`[MCP Orchestrator] No tools discovered from ${config.name} (will retry on first use)`)
       }
+      this.notifyToolsUpdated(config.name)
     } catch (_error) {
       // Tool discovery failed but connection succeeded - tools will be discovered on first use
       this.tools.set(config.name, [])
       console.log(`[MCP Orchestrator] Tool discovery deferred for ${config.name} (will discover on first tool call)`)
+      this.notifyToolsUpdated(config.name)
     }
   }
 
@@ -167,16 +166,10 @@ export class MCPClientManager {
     }
 
     try {
-      const result = await client.request(
-        {
-          method: "tools/call",
-          params: {
-            name: toolName,
-            arguments: args
-          }
-        },
-        undefined as any // Type inference will work at runtime
-      )
+      const result = await client.callTool({
+        name: toolName,
+        arguments: args
+      })
 
       return result as CallToolResult
     } catch (error) {
@@ -199,6 +192,66 @@ export class MCPClientManager {
     return Array.from(this.clients.keys())
   }
 
+  /**
+   * Subscribe to tool updates for a specific MCP. Returns an unsubscribe function.
+   */
+  onToolsUpdated(subscriber: (info: { mcpName: string; tools: Tool[] }) => void): () => void {
+    this.toolUpdateSubscribers.push(subscriber)
+    return () => {
+      this.toolUpdateSubscribers = this.toolUpdateSubscribers.filter((fn) => fn !== subscriber)
+    }
+  }
+
+  /**
+   * Wait for at least one downstream MCP to finish tool discovery, or resolve after a timeout.
+   * Prevents registering an empty toolset before downstream servers are ready.
+   */
+  async waitForInitialTools(timeoutMs: number = 8000): Promise<void> {
+    if (this.getAllTools().length > 0) {
+      return
+    }
+
+    await new Promise<void>((resolve) => {
+      let timeoutId: NodeJS.Timeout
+
+      const onDiscovery = () => {
+        clearTimeout(timeoutId)
+        this.toolDiscoveryListeners = this.toolDiscoveryListeners.filter((listener) => listener !== onDiscovery)
+        resolve()
+      }
+
+      timeoutId = setTimeout(() => {
+        this.toolDiscoveryListeners = this.toolDiscoveryListeners.filter((listener) => listener !== onDiscovery)
+        resolve()
+      }, timeoutMs)
+
+      this.toolDiscoveryListeners.push(onDiscovery)
+    })
+  }
+
+  private notifyToolDiscovery(): void {
+    if (this.toolDiscoveryListeners.length === 0 || this.getAllTools().length === 0) {
+      return
+    }
+
+    const listeners = [...this.toolDiscoveryListeners]
+    this.toolDiscoveryListeners = []
+    for (const listener of listeners) {
+      listener()
+    }
+  }
+
+  private notifyToolsUpdated(mcpName: string): void {
+    const tools = this.tools.get(mcpName) ?? []
+    for (const subscriber of this.toolUpdateSubscribers) {
+      try {
+        subscriber({ mcpName, tools })
+      } catch (error) {
+        console.warn(`[MCP Orchestrator] Tool update subscriber error for ${mcpName}:`, error)
+      }
+    }
+  }
+
   /**
    * Schedule reconnection for a disconnected MCP
    */

package/mcp-server/app/mcp/route.ts

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs"
 import { homedir } from "node:os"
 import { join } from "node:path"
+import type { Tool } from "@modelcontextprotocol/sdk/types.js"
 import { createMcpHandler } from "mcp-handler"
 import { z } from "zod"
 import { getMCPClientManager } from "./client-manager"
@@ -95,14 +96,39 @@ const initializeOrchestration = async () => {
     return config
   }
 
+  const waitForInitialConfig = async (
+    timeoutMs: number = 10000,
+    pollIntervalMs: number = 250
+  ): Promise<{ config: Parameters<typeof clientManager.initialize>[0]; waited: boolean }> => {
+    const startTime = Date.now()
+    let waited = false
+    let config = getConfigFromSessions()
+
+    while (Object.keys(config).length === 0 && Date.now() - startTime < timeoutMs) {
+      if (!waited) {
+        console.log("[MCP Orchestrator] Waiting for session info before connecting downstream MCPs...")
+        waited = true
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs))
+      config = getConfigFromSessions()
+    }
+
+    return { config, waited }
+  }
+
   try {
     // Initial attempt to connect
-    const config = getConfigFromSessions()
+    const { config, waited } = await waitForInitialConfig()
     if (Object.keys(config).length > 0) {
       await clientManager.initialize(config)
       console.log(`[MCP Orchestrator] Initialized with ${Object.keys(config).join(", ")}`)
     } else {
-      console.log("[MCP Orchestrator] No downstream MCPs found yet (will retry)")
+      if (waited) {
+        console.log("[MCP Orchestrator] No downstream MCPs detected after waiting for session info (will retry)")
+      } else {
+        console.log("[MCP Orchestrator] No downstream MCPs found yet (will retry)")
+      }
     }
 
     // Since MCP server starts before Chrome, periodically retry connection
@@ -146,29 +172,128 @@ const initializeOrchestration = async () => {
 }
 
 // Initialize on module load
-initializeOrchestration().catch(console.error)
+const orchestrationReady = initializeOrchestration().catch((error) => {
+  console.error("[MCP Orchestrator] Failed to initialize downstream MCPs:", error)
+})
 
 const handler = createMcpHandler(
-  (server) => {
-    // Dynamically register proxied tools from downstream MCPs
+  async (server) => {
     const clientManager = getMCPClientManager()
-    const downstreamTools = clientManager.getAllTools()
 
-    for (const { mcpName, tool } of downstreamTools) {
-      // Add prefix to avoid conflicts with dev3000's own tools
+    await orchestrationReady
+    await clientManager.waitForInitialTools()
+
+    const registeredProxiedTools = new Map<
+      string,
+      {
+        mcpName: string
+        toolName: string
+        registered: ReturnType<typeof server.tool>
+      }
+    >()
+
+    const registerOrUpdateProxiedTool = (mcpName: string, tool: Tool): boolean => {
       const proxiedToolName = `${mcpName}_${tool.name}`
+      const existing = registeredProxiedTools.get(proxiedToolName)
+      const description = `[${mcpName}] ${tool.description || ""}`
+      const annotations = {
+        ...(tool.annotations ?? {}),
+        proxiedFrom: mcpName,
+        originalInputSchema: tool.inputSchema
+      }
+
+      if (existing) {
+        existing.registered.update({
+          description,
+          annotations
+        })
+        return false
+      }
 
-      server.tool(
-        proxiedToolName,
-        `[${mcpName}] ${tool.description || ""}`,
-        tool.inputSchema as any,
-        async (params: Record<string, unknown>) => {
-          // Proxy the call to the downstream MCP
+      try {
+        const proxiedTool = server.tool(proxiedToolName, description, {}, async (params: Record<string, unknown>) => {
           return clientManager.callTool(mcpName, tool.name, params)
+        })
+
+        // Allow arbitrary argument objects to pass through to downstream MCPs
+        proxiedTool.inputSchema = z.object({}).passthrough()
+
+        proxiedTool.update({
+          annotations
+        })
+
+        registeredProxiedTools.set(proxiedToolName, {
+          mcpName,
+          toolName: tool.name,
+          registered: proxiedTool
+        })
+
+        console.log(`[MCP Orchestrator] Registered proxied tool ${proxiedToolName}`)
+        return true
+      } catch (error) {
+        console.warn(`[MCP Orchestrator] Failed to register proxied tool ${proxiedToolName}:`, error)
+        return false
+      }
+    }
+
+    const removeToolsForMcp = (mcpName: string): number => {
+      let removed = 0
+      for (const [proxiedToolName, entry] of registeredProxiedTools.entries()) {
+        if (entry.mcpName === mcpName) {
+          try {
+            entry.registered.remove()
+            registeredProxiedTools.delete(proxiedToolName)
+            removed++
+            console.log(`[MCP Orchestrator] Removed proxied tool ${proxiedToolName}`)
+          } catch (error) {
+            console.warn(`[MCP Orchestrator] Failed to remove proxied tool ${proxiedToolName}:`, error)
+          }
         }
-      )
+      }
+      return removed
     }
 
+    // Dynamically register proxied tools from downstream MCPs
+    const downstreamTools = clientManager.getAllTools()
+
+    if (downstreamTools.length === 0) {
+      console.log("[MCP Orchestrator] No downstream MCP tools available during initial registration")
+    } else {
+      console.log(`[MCP Orchestrator] Registering ${downstreamTools.length} downstream MCP tools`)
+    }
+
+    let initialNewTools = 0
+    for (const { mcpName, tool } of downstreamTools) {
+      if (registerOrUpdateProxiedTool(mcpName, tool)) {
+        initialNewTools++
+      }
+    }
+
+    if (initialNewTools > 0) {
+      server.sendToolListChanged()
+    }
+
+    clientManager.onToolsUpdated(({ mcpName, tools }) => {
+      if (tools.length === 0) {
+        const removed = removeToolsForMcp(mcpName)
+        if (removed > 0) {
+          server.sendToolListChanged()
+        }
+        return
+      }
+
+      let addedOrUpdated = 0
+      for (const tool of tools) {
+        if (registerOrUpdateProxiedTool(mcpName, tool)) {
+          addedOrUpdated++
+        }
+      }
+
+      if (addedOrUpdated > 0) {
+        server.sendToolListChanged()
+      }
+    })
+
     // Dev3000's own tools below:
     // Enhanced fix_my_app - the ultimate error fixing tool
     server.tool(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dev3000",
-  "version": "0.0.92",
+  "version": "0.0.94",
   "description": "AI-powered development tools with browser monitoring and MCP server integration",
   "type": "module",
   "main": "dist/index.js",

package/src/tui-interface-impl.tsx

@@ -20,6 +20,8 @@ interface LogEntry {
   content: string
 }
 
+const NEXTJS_MCP_404_REGEX = /(?:\[POST\]|POST)\s+\/_next\/mcp\b[^\n]*\b404\b/i
+
 // Compact ASCII logo for very small terminals
 const COMPACT_LOGO = "d3k"
 
@@ -148,6 +150,10 @@ const TUIApp = ({
     let buffer = ""
 
     const appendLog = (line: string) => {
+      if (NEXTJS_MCP_404_REGEX.test(line)) {
+        return
+      }
+
       const newLog: LogEntry = {
         id: logIdCounter.current++,
         content: line