dev3000 0.0.157 → 0.0.159

package/mcp-server/app/logs/page.tsx

@@ -1,150 +0,0 @@
-import { extractProjectNameFromLogFilename, logFilenameMatchesProject } from "@dev3000/src/utils/log-filename"
-import { existsSync, readdirSync, readFileSync, statSync } from "fs"
-import { redirect } from "next/navigation"
-import { basename, dirname, join } from "path"
-import LogsClient from "./LogsClient"
-import { parseLogEntries } from "./utils"
-
-interface PageProps {
-  searchParams: Promise<{ file?: string; mode?: "head" | "tail"; project?: string }>
-}
-
-async function getLogFiles() {
-  try {
-    const currentLogPath = process.env.LOG_FILE_PATH || "/var/log/dev3000/dev3000.log"
-
-    if (!existsSync(currentLogPath)) {
-      return { files: [], currentFile: "", projectName: "unknown" }
-    }
-
-    const logDir = dirname(currentLogPath)
-    const currentLogName = basename(currentLogPath)
-
-    // Extract project name from current log filename using shared utility
-    const projectName = extractProjectNameFromLogFilename(currentLogName) || "unknown"
-
-    const dirContents = readdirSync(logDir)
-    const logFiles = dirContents
-      // Get all log files for this project
-      .filter((file) => logFilenameMatchesProject(file, projectName))
-      .map((file) => {
-        const filePath = join(logDir, file)
-        const stats = statSync(filePath)
-
-        const timestampMatch = file.match(/(\d{4}-\d{2}-\d{2}T[\d-]+Z)/)
-        const timestamp = timestampMatch ? timestampMatch[1].replace(/-/g, ":") : ""
-
-        return {
-          name: file,
-          path: filePath,
-          timestamp,
-          size: stats.size,
-          mtime: stats.mtime,
-          isCurrent: file === currentLogName
-        }
-      })
-      .sort((a, b) => b.mtime.getTime() - a.mtime.getTime())
-      .map((file) => ({
-        ...file,
-        mtime: file.mtime.toISOString() // Convert to string after sorting
-      }))
-
-    return {
-      files: logFiles,
-      currentFile: currentLogPath,
-      projectName
-    }
-  } catch (_error) {
-    return { files: [], currentFile: "", projectName: "unknown" }
-  }
-}
-
-async function getLogData(logPath: string, mode: "head" | "tail" = "tail", lines: number = 100) {
-  try {
-    if (!existsSync(logPath)) {
-      return { logs: "", total: 0 }
-    }
-
-    const logContent = readFileSync(logPath, "utf-8")
-    const allLines = logContent.split("\n").filter((line) => line.trim())
-
-    const selectedLines = mode === "head" ? allLines.slice(0, lines) : allLines.slice(-lines)
-
-    return {
-      logs: selectedLines.join("\n"),
-      total: allLines.length
-    }
-  } catch (_error) {
-    return { logs: "", total: 0 }
-  }
-}
-
-export default async function LogsPage({ searchParams }: PageProps) {
-  const version = process.env.DEV3000_VERSION || "0.0.0"
-
-  // Await searchParams (Next.js 15 requirement)
-  const params = await searchParams
-
-  // Get available log files
-  const { files, currentFile } = await getLogFiles()
-
-  // If project parameter is provided, find latest file for that project
-  if (params.project && !params.file) {
-    // Look for files that match the project name (supports partial matching)
-    const projectFiles = files.filter((f) => logFilenameMatchesProject(f.name, params.project ?? ""))
-    if (projectFiles.length > 0) {
-      redirect(`/logs?file=${encodeURIComponent(projectFiles[0].name)}&mode=tail`)
-    }
-    // If no matching project files found but we have other files, show the latest
-    else if (files.length > 0) {
-      redirect(`/logs?file=${encodeURIComponent(files[0].name)}&mode=tail`)
-    }
-    // Otherwise fall through to render empty state
-  }
-
-  // If no file specified and we have files, redirect to latest with tail mode
-  else if (!params.file && files.length > 0) {
-    const latestFile = files[0].name
-    redirect(`/logs?file=${encodeURIComponent(latestFile)}&mode=tail`)
-  }
-
-  // If no file specified and no files available, render with empty data
-  if (!params.file) {
-    return (
-      <LogsClient
-        version={version}
-        initialData={{
-          logs: [],
-          logFiles: [],
-          currentLogFile: "",
-          mode: "tail"
-        }}
-      />
-    )
-  }
-
-  // Find the selected log file
-  const selectedFile = files.find((f) => f.name === params.file)
-  const logPath = selectedFile?.path || currentFile
-
-  // Always default to 'tail' mode for initial loads
-  const _isCurrentFile = selectedFile?.isCurrent !== false
-  const defaultMode = "tail" // Always start in tail mode
-  const mode = (params.mode as "head" | "tail") || defaultMode
-
-  // Get initial log data server-side
-  const logData = await getLogData(logPath, mode)
-  const parsedLogs = parseLogEntries(logData.logs)
-
-  return (
-    <LogsClient
-      version={version}
-      initialData={{
-        logs: parsedLogs,
-        logFiles: files,
-        currentLogFile: logPath,
-        mode
-      }}
-    />
-  )
-}

package/mcp-server/app/logs/utils.ts

@@ -1,151 +0,0 @@
-import type { LogEntry } from "@/types"
-
-/**
- * Cleans up console log messages that contain CSS formatting directives
- * Example: "%c[Vercel Web Analytics]%c Debug mode... color: rgb(120, 120, 120) color: inherit"
- * Becomes: "[Vercel Web Analytics] Debug mode..."
- */
-function cleanConsoleFormatting(message: string): string {
-  // Pattern to match console log entries with CSS formatting
-  const consoleLogPattern = /^\[CONSOLE LOG\] (.+)$/
-  const match = message.match(consoleLogPattern)
-
-  if (!match) {
-    return message
-  }
-
-  const consoleMessage = match[1]
-
-  // Check if this message has %c CSS formatting directives
-  if (!consoleMessage.includes("%c")) {
-    return message // No formatting to clean
-  }
-
-  // Remove CSS formatting directives step by step
-  let cleaned = consoleMessage
-
-  // Remove %c markers
-  cleaned = cleaned.replace(/%c/g, "")
-
-  // Remove trailing CSS color declarations - look for CSS patterns before JSON or at end of string
-  // Match CSS color declarations that appear after %c removal
-  cleaned = cleaned.replace(/\s+color:\s*[^{}\n]*?(?=\s*[{[]|$)/g, "")
-
-  // Clean up any extra whitespace
-  cleaned = cleaned.replace(/\s+/g, " ").trim()
-
-  return `[CONSOLE LOG] ${cleaned}`
-}
-
-export function parseLogEntries(logContent: string): LogEntry[] {
-  // Enhanced pattern to handle multiple timestamp formats:
-  // Format 1 (CDP): [timestamp] [SOURCE] message
-  // Format 2 (Extension): [timestamp] [TAB-id] [SOURCE] [event] message
-  // Format 3 (Short): [HH:MM:SS.mmm] [SOURCE] message
-  const timestampPattern = /\[(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z|\d{2}:\d{2}:\d{2}\.\d{3})\] \[([^\]]+)\] /
-
-  const entries: LogEntry[] = []
-  const lines = logContent.split("\n")
-  let currentEntry: LogEntry | null = null
-
-  for (const line of lines) {
-    if (!line.trim()) continue
-
-    const match = line.match(timestampPattern)
-    if (match) {
-      // Save previous entry if exists
-      if (currentEntry) {
-        entries.push(currentEntry)
-      }
-
-      const [fullMatch, timestamp, firstBracket] = match
-      const remainingLine = line.substring(fullMatch.length)
-
-      // Check if this is a Chrome extension format with tab identifier
-      const isTabIdentifier = /^TAB-\d+\.\d+$/.test(firstBracket)
-      let source = firstBracket
-      let message = remainingLine
-      let tabIdentifier: string | undefined
-      let userAgent: string | undefined
-
-      if (isTabIdentifier) {
-        // Chrome extension format: [TAB-id] [SOURCE] [event] message
-        tabIdentifier = firstBracket
-
-        // Look for the next bracketed section which should be the actual source
-        const sourceMatch = remainingLine.match(/^\[([^\]]+)\] /)
-        if (sourceMatch) {
-          source = sourceMatch[1] // This should be "BROWSER"
-          message = remainingLine.substring(sourceMatch[0].length)
-
-          // Extract user agent from INFO entries if present
-          if (message.includes("User-Agent:")) {
-            const uaMatch = message.match(/User-Agent: ([^,\n]+)/)
-            if (uaMatch) {
-              userAgent = uaMatch[1]
-            }
-          }
-        }
-      }
-
-      const screenshot = message.match(/\[SCREENSHOT\] ([^\s[]+)/)?.[1]
-      const screencast = message.match(/\[SCREENCAST\] View jank analysis: ([^\s]+)/)?.[1]
-
-      // Clean up CSS formatting directives in console log messages
-      let cleanedMessage = cleanConsoleFormatting(message)
-
-      // Remove browser type markers from displayed message (they'll show as pills instead)
-      // cleanedMessage = cleanedMessage.replace(/ \[PLAYWRIGHT\]$/, "").replace(/ \[CHROME_EXTENSION\]$/, "")
-      cleanedMessage = cleanedMessage.replace(/ \[CHROME_EXTENSION\]$/, "") // Only remove Chrome Extension tag
-
-      // Filter out noisy WebSocket logs from Next.js dev server
-      const isNoisyWebSocketLog =
-        cleanedMessage.includes("[Network.webSocketFrameSent]") ||
-        cleanedMessage.includes("[Network.webSocketFrameReceived]") ||
-        cleanedMessage.includes("[Network.webSocketFrame") ||
-        (cleanedMessage.includes("webSocketDebuggerUrl") && cleanedMessage.includes("localhost")) ||
-        (cleanedMessage.includes("[NETWORK") &&
-          cleanedMessage.includes("__PAGE__") &&
-          cleanedMessage.includes("refresh"))
-
-      // Skip noisy WebSocket logs unless user specifically wants to see them
-      if (isNoisyWebSocketLog) {
-        currentEntry = null // Skip this entry
-        continue
-      }
-
-      // Normalize timestamp to full ISO format if it's just time
-      let normalizedTimestamp = timestamp
-      if (/^\d{2}:\d{2}:\d{2}\.\d{3}$/.test(timestamp)) {
-        // It's just HH:MM:SS.mmm, convert to today's date with this time
-        const today = new Date()
-        const [hours, minutes, secondsMs] = timestamp.split(":")
-        const [seconds, ms] = secondsMs.split(".")
-        today.setHours(parseInt(hours, 10), parseInt(minutes, 10), parseInt(seconds, 10), parseInt(ms, 10))
-        normalizedTimestamp = today.toISOString()
-      }
-
-      currentEntry = {
-        timestamp: normalizedTimestamp,
-        source,
-        message: cleanedMessage,
-        screenshot,
-        screencast,
-        original: line,
-        tabIdentifier,
-        userAgent
-      }
-    } else if (currentEntry) {
-      // Append to current entry's message
-      currentEntry.message += `\n${line}`
-      currentEntry.original += `\n${line}`
-    }
-  }
-
-  // Don't forget the last entry
-  if (currentEntry) {
-    entries.push(currentEntry)
-  }
-
-  return entries
-}

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

@@ -1,346 +0,0 @@
-/**
- * MCP Client Manager - Orchestrates connections to downstream MCP servers
- *
- * This implements the "orchestrator" or "gateway" pattern where dev3000 acts as:
- * - MCP Server (to AI clients like Claude)
- * - MCP Client (to chrome-devtools and nextjs-dev MCPs)
- *
- * Benefits:
- * - Users only configure dev3000 once globally
- * - Auto-discovery of chrome-devtools and nextjs-dev MCPs
- * - Reduced context bloat for AI clients
- * - Intelligent orchestration across multiple MCP sources
- */
-
-import { Client } from "@modelcontextprotocol/sdk/client/index.js"
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
-import type { CallToolResult, Tool } from "@modelcontextprotocol/sdk/types.js"
-
-interface MCPClientConfig {
-  name: string
-  type: "http" | "stdio"
-  url?: string // For HTTP transport
-  command?: string // For stdio transport
-  args?: string[] // For stdio transport
-  enabled: boolean
-}
-
-export class MCPClientManager {
-  private clients: Map<string, Client> = new Map()
-  private transports: Map<string, StreamableHTTPClientTransport | StdioClientTransport> = new Map()
-  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
-   */
-  async initialize(config: {
-    chromeDevtools?: { command: string; args: string[]; enabled: boolean }
-    nextjsDev?: { command: string; args: string[]; enabled: boolean }
-    svelteDev?: { command: string; args: string[]; enabled: boolean }
-  }): Promise<void> {
-    const configs: MCPClientConfig[] = []
-
-    if (config.chromeDevtools?.enabled) {
-      configs.push({
-        name: "chrome-devtools",
-        type: "stdio",
-        command: config.chromeDevtools.command,
-        args: config.chromeDevtools.args,
-        enabled: true
-      })
-    }
-
-    if (config.nextjsDev?.enabled) {
-      configs.push({
-        name: "nextjs-dev",
-        type: "stdio",
-        command: config.nextjsDev.command,
-        args: config.nextjsDev.args,
-        enabled: true
-      })
-    }
-
-    if (config.svelteDev?.enabled) {
-      configs.push({
-        name: "svelte-dev",
-        type: "stdio",
-        command: config.svelteDev.command,
-        args: config.svelteDev.args,
-        enabled: true
-      })
-    }
-
-    // Connect to each available MCP
-    for (const cfg of configs) {
-      try {
-        await this.connectToMCP(cfg)
-        const location = cfg.type === "http" ? cfg.url : `${cfg.command} ${cfg.args?.join(" ")}`
-        console.log(`[MCP Orchestrator] Connected to ${cfg.name} (${cfg.type}) at ${location}`)
-      } catch (error) {
-        console.warn(`[MCP Orchestrator] Failed to connect to ${cfg.name}:`, error)
-      }
-    }
-  }
-
-  /**
-   * Connect to a downstream MCP server
-   */
-  private async connectToMCP(config: MCPClientConfig): Promise<void> {
-    // Store config for reconnection
-    this.lastConfigs.set(config.name, config)
-
-    const client = new Client(
-      {
-        name: "dev3000-orchestrator",
-        version: "1.0.0"
-      },
-      {
-        capabilities: {}
-      }
-    )
-
-    client.onerror = (error) => {
-      console.error(`[MCP Orchestrator] ${config.name} error:`, error)
-      // Schedule reconnection for HTTP transports (SSE disconnects)
-      if (config.type === "http") {
-        this.scheduleReconnect(config.name)
-      }
-    }
-
-    let transport: StreamableHTTPClientTransport | StdioClientTransport
-
-    if (config.type === "http" && config.url) {
-      transport = new StreamableHTTPClientTransport(new URL(config.url))
-    } else if (config.type === "stdio" && config.command) {
-      transport = new StdioClientTransport({
-        command: config.command,
-        args: config.args || []
-      })
-    } else {
-      throw new Error(`Invalid MCP config for ${config.name}`)
-    }
-
-    await client.connect(transport)
-
-    this.clients.set(config.name, client)
-    this.transports.set(config.name, transport)
-
-    // Discover available tools (non-fatal - connection already succeeded)
-    try {
-      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 {
-        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)
-    }
-  }
-
-  /**
-   * Get all discovered tools from all connected MCPs
-   */
-  getAllTools(): Array<{ mcpName: string; tool: Tool }> {
-    const allTools: Array<{ mcpName: string; tool: Tool }> = []
-
-    for (const [mcpName, tools] of this.tools.entries()) {
-      for (const tool of tools) {
-        allTools.push({ mcpName, tool })
-      }
-    }
-
-    return allTools
-  }
-
-  /**
-   * Call a tool on a downstream MCP server
-   */
-  async callTool(mcpName: string, toolName: string, args: Record<string, unknown>): Promise<CallToolResult> {
-    const client = this.clients.get(mcpName)
-
-    if (!client) {
-      throw new Error(`MCP client '${mcpName}' not connected`)
-    }
-
-    try {
-      const result = await client.callTool({
-        name: toolName,
-        arguments: args
-      })
-
-      return result as CallToolResult
-    } catch (error) {
-      console.error(`[MCP Orchestrator] Error calling ${mcpName}.${toolName}:`, error)
-      throw error
-    }
-  }
-
-  /**
-   * Check if a specific MCP is connected
-   */
-  isConnected(mcpName: string): boolean {
-    return this.clients.has(mcpName)
-  }
-
-  /**
-   * Get list of connected MCP names
-   */
-  getConnectedMCPs(): string[] {
-    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
-   */
-  private scheduleReconnect(mcpName: string): void {
-    // Clear any existing reconnect timer
-    const existingTimer = this.reconnectTimers.get(mcpName)
-    if (existingTimer) {
-      clearTimeout(existingTimer)
-    }
-
-    // Schedule reconnection after 3 seconds
-    const timer = setTimeout(async () => {
-      const config = this.lastConfigs.get(mcpName)
-      if (!config) {
-        console.warn(`[MCP Orchestrator] No config found for reconnection: ${mcpName}`)
-        return
-      }
-
-      console.log(`[MCP Orchestrator] Attempting to reconnect to ${mcpName}...`)
-      try {
-        // Clean up old connection
-        const oldTransport = this.transports.get(mcpName)
-        if (oldTransport) {
-          try {
-            await oldTransport.close()
-          } catch {
-            // Ignore close errors
-          }
-        }
-        this.clients.delete(mcpName)
-        this.transports.delete(mcpName)
-
-        // Attempt reconnection
-        await this.connectToMCP(config)
-        console.log(`[MCP Orchestrator] Successfully reconnected to ${mcpName}`)
-      } catch (error) {
-        console.warn(`[MCP Orchestrator] Reconnection to ${mcpName} failed:`, error)
-        // Schedule another retry
-        this.scheduleReconnect(mcpName)
-      }
-    }, 3000)
-
-    this.reconnectTimers.set(mcpName, timer)
-  }
-
-  /**
-   * Disconnect all MCP clients
-   */
-  async disconnect(): Promise<void> {
-    // Clear all reconnect timers
-    for (const timer of this.reconnectTimers.values()) {
-      clearTimeout(timer)
-    }
-    this.reconnectTimers.clear()
-
-    for (const [name, transport] of this.transports.entries()) {
-      try {
-        await transport.close()
-        console.log(`[MCP Orchestrator] Disconnected from ${name}`)
-      } catch (error) {
-        console.error(`[MCP Orchestrator] Error disconnecting from ${name}:`, error)
-      }
-    }
-
-    this.clients.clear()
-    this.transports.clear()
-    this.tools.clear()
-    this.lastConfigs.clear()
-  }
-}
-
-// Singleton instance
-let clientManager: MCPClientManager | null = null
-
-export function getMCPClientManager(): MCPClientManager {
-  if (!clientManager) {
-    clientManager = new MCPClientManager()
-  }
-  return clientManager
-}