dev3000 0.0.101 → 0.0.103

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

@@ -1 +1 @@
-self.__RSC_SERVER_MANIFEST="{\n  \"node\": {},\n  \"edge\": {},\n  \"encryptionKey\": \"/PxvsAvzRaWzXUHwWLug3ZcveweVRuE36Tz0vOuDXP8=\"\n}"
+self.__RSC_SERVER_MANIFEST="{\n  \"node\": {},\n  \"edge\": {},\n  \"encryptionKey\": \"5LNEsGYjtwWobrqfCSeqJHwMBqVNoQL+Ca6PZ7kLWsc=\"\n}"

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

@@ -1,5 +1,5 @@
 {
   "node": {},
   "edge": {},
-  "encryptionKey": "/PxvsAvzRaWzXUHwWLug3ZcveweVRuE36Tz0vOuDXP8="
+  "encryptionKey": "5LNEsGYjtwWobrqfCSeqJHwMBqVNoQL+Ca6PZ7kLWsc="
 }

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

@@ -5,7 +5,14 @@ import type { Tool } from "@modelcontextprotocol/sdk/types.js"
 import { createMcpHandler } from "mcp-handler"
 import { z } from "zod"
 import { getMCPClientManager } from "./client-manager"
-import { executeBrowserAction, findComponentSource, fixMyApp, restartDevServer, TOOL_DESCRIPTIONS } from "./tools"
+import {
+  crawlApp,
+  executeBrowserAction,
+  findComponentSource,
+  fixMyApp,
+  restartDevServer,
+  TOOL_DESCRIPTIONS
+} from "./tools"
 
 // Detect available package runner (bunx, npx, pnpm dlx, or fail)
 const getPackageRunner = (): { command: string; args: string[] } | null => {
@@ -412,7 +419,8 @@ const handler = createMcpHandler(
         returnRawData: z
           .boolean()
           .optional()
-          .describe("Return structured data for Claude orchestration instead of formatted text")
+          .describe("Return structured data for Claude orchestration instead of formatted text"),
+        createPR: z.boolean().optional().describe("Create a PR for the highest priority issue (default: false)")
       },
       async (params) => {
         return fixMyApp(params)
@@ -502,6 +510,24 @@ const handler = createMcpHandler(
       }
     )
 
+    // App crawler tool
+    server.tool(
+      "crawl_app",
+      TOOL_DESCRIPTIONS.crawl_app,
+      {
+        depth: z
+          .union([z.number().int().min(1), z.literal("all")])
+          .optional()
+          .describe(
+            "Crawl depth: number (1=homepage only, 2=homepage+next level, etc.) or 'all' for exhaustive (default: 1)"
+          ),
+        projectName: z.string().optional().describe("Project name (if multiple dev3000 instances are running)")
+      },
+      async (params) => {
+        return crawlApp(params)
+      }
+    )
+
     // Tool that returns monitoring code for Claude to execute
     // TODO: Commenting out for now - need to figure out the right approach for proactive monitoring
     /*

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

@@ -12,7 +12,7 @@ const execAsync = promisify(exec)
 // Tool descriptions
 export const TOOL_DESCRIPTIONS = {
   fix_my_app:
-    "🔧 **THE ULTIMATE FIND→FIX→VERIFY MACHINE!** This tool doesn't just find bugs - it FIXES them! Pure dev3000 magic that identifies issues, provides exact fixes, and verifies everything works! 🪄\n\n🔥 **INSTANT FIXING SUPERPOWERS:**\n• Detects ALL error types: server crashes, browser errors, build failures, API issues, performance problems\n• Shows EXACT user interactions that triggered each error (clicks, navigation, etc.)\n• Provides EXACT fix code with file locations and line numbers\n• Guides you through implementing fixes step-by-step\n• Verifies fixes by replaying the same interactions that caused the error!\n\n📍 **INTERACTION-BASED VERIFICATION:**\n• Every error includes the user interactions that led to it\n• Use execute_browser_action to replay these exact interactions\n• Verify your fix works by confirming the error doesn't reoccur\n• Example: Error shows '[INTERACTION] Click at (450,300)' → After fix, use execute_browser_action(action='click', params={x:450, y:300}) to verify\n\n⚡ **3 ACTION MODES:**\n• FIX NOW: 'What's broken RIGHT NOW?' → Find and fix immediately\n• FIX REGRESSION: 'What broke during testing?' → Compare before/after and fix\n• FIX CONTINUOUSLY: 'Fix issues as they appear' → Monitor and fix proactively\n\n🎪 **THE FIX-IT WORKFLOW:**\n1️⃣ I FIND all issues with their triggering interactions\n2️⃣ I provide EXACT FIXES with code snippets\n3️⃣ You implement the fixes\n4️⃣ We REPLAY the interactions to VERIFY everything works\n\n💡 **PERFECT FOR:** 'fix my app' or 'debug my app' requests, error resolution, code repairs, making broken apps work again. This tool doesn't just identify problems - it SOLVES them with precise reproduction steps!",
+    "🔧 **THE ULTIMATE FIND→FIX→VERIFY MACHINE!** This tool doesn't just find bugs - it FIXES them! Pure dev3000 magic that identifies issues, prioritizes them, and creates focused PRs for the worst issue! 🪄\n\n🔥 **INSTANT FIXING SUPERPOWERS:**\n• Detects ALL error types: server crashes, browser errors, build failures, API issues, performance problems\n• **PRIORITIZES errors** using smart scoring (build > server > browser > network > warnings)\n• **Identifies the SINGLE WORST issue** that needs fixing right now\n• **Creates ONE focused PR** per run - no overwhelming multi-issue PRs!\n• Shows EXACT user interactions that triggered each error (clicks, navigation, etc.)\n• Provides EXACT fix code with file locations and line numbers\n• Verifies fixes by replaying the same interactions that caused the error!\n\n🎯 **SMART PRIORITIZATION:**\n• Build errors: 1000+ priority (blocks development)\n• Server errors: 500+ priority (affects functionality)\n• Browser errors: 300+ priority (user-facing issues)\n• Network errors: 200+ priority (intermittent issues)\n• Warnings: 100+ priority (nice to fix)\n• +Modifiers: Multiple occurrences, recency, reproducibility\n\n🚀 **ONE-PR-PER-RUN WORKFLOW:**\n1️⃣ I FIND all issues and their interactions\n2️⃣ I PRIORITIZE using smart scoring algorithm\n3️⃣ I IDENTIFY the single worst issue\n4️⃣ Set createPR=true to CREATE A FOCUSED PR for just that issue\n5️⃣ Fix that ONE issue, then run again for the next worst issue\n\n📍 **INTERACTION-BASED VERIFICATION:**\n• Every error includes the user interactions that led to it\n• Use execute_browser_action to replay these exact interactions\n• Verify your fix works by confirming the error doesn't reoccur\n• Example: Error shows '[INTERACTION] Click at (450,300)' → After fix, use execute_browser_action(action='click', params={x:450, y:300}) to verify\n\n⚡ **3 ACTION MODES:**\n• FIX NOW: 'What's broken RIGHT NOW?' → Find worst issue and optionally create PR\n• FIX REGRESSION: 'What broke during testing?' → Compare before/after and fix worst issue\n• FIX CONTINUOUSLY: 'Fix issues as they appear' → Monitor and fix proactively\n\n💡 **PERFECT FOR:** 'fix my app' or 'debug my app' or 'create pr for worst issue' requests. This tool identifies problems, ranks them by severity, and creates focused single-issue PRs - not giant multi-fix PRs!",
 
   execute_browser_action:
     "🌐 **INTELLIGENT BROWSER AUTOMATION** - Smart browser action routing that automatically delegates to chrome-devtools MCP when available for superior automation capabilities.\n\n🎯 **INTELLIGENT DELEGATION:**\n• Screenshots → chrome-devtools MCP (better quality, no conflicts)\n• Navigation → chrome-devtools MCP (more reliable page handling)\n• Clicks → chrome-devtools MCP (precise coordinate-based interaction)\n• JavaScript evaluation → chrome-devtools MCP (enhanced debugging)\n• Scrolling & typing → dev3000 fallback (specialized actions)\n\n⚡ **PROGRESSIVE ENHANCEMENT:**\n• Uses chrome-devtools MCP when available for best results\n• Falls back to dev3000's native implementation when chrome-devtools unavailable\n• Shares the same Chrome instance via CDP URL coordination\n• Eliminates browser conflicts between tools\n\n💡 **PERFECT FOR:** Browser automation that automatically chooses the best tool for each action, ensuring optimal results whether chrome-devtools MCP is available or not.",
@@ -24,7 +24,10 @@ export const TOOL_DESCRIPTIONS = {
     "🔍 **COMPONENT SOURCE FINDER** - Maps DOM elements to their source code by extracting the React component function and finding unique patterns to search for.\n\n🎯 **HOW IT WORKS:**\n• Inspects the element via Chrome DevTools Protocol\n• Extracts the React component function source using .toString()\n• Identifies unique code patterns (specific JSX, classNames, imports)\n• Returns targeted grep patterns to find the exact source file\n\n💡 **PERFECT FOR:** Finding which file contains the code for a specific element, especially useful for CLS debugging when you need to fix layout shifts in specific components.",
 
   restart_dev_server:
-    "🔄 **DEV SERVER RESTART** - Safely restarts the development server while preserving dev3000's monitoring, logs, and browser connection.\n\n🎯 **SMART RESTART LOGIC:**\n• First tries nextjs-dev MCP restart (if available and user has Next.js canary)\n• Falls back to dev3000's own restart mechanism:\n  - Kills the old server process on the app port\n  - Waits for clean shutdown\n  - Spawns a new server with the same command that was originally used\n  - Keeps dev3000's MCP server, browser monitoring, and screenshot capture running\n• All logging continues seamlessly - no data loss\n• Browser monitoring stays connected - no need to relaunch Chrome\n\n⚡ **WHEN TO USE:**\n• After modifying next.config.js, middleware, or environment variables\n• When you need a clean restart to clear server state\n• After significant code changes that Next.js HMR can't handle\n• When debugging persistent state or memory issues\n\n⚠️ **CRITICAL - DO NOT:**\n• ❌ NEVER manually run kill commands on the dev server like `pkill -f \"next dev\"` or `lsof -ti :3000 | xargs kill`\n• ❌ NEVER manually start the dev server with `npm run dev`, `pnpm dev`, `next dev`, etc.\n• ✅ ALWAYS use this tool for dev server restarts - it preserves all dev3000 infrastructure\n\n⚠️ **IMPORTANT:**\n• AVOID using this unnecessarily - Next.js HMR handles most changes automatically\n• Only restart when truly needed for config changes or state issues\n• The server will be offline for a few seconds during restart\n• Browser may show connection error briefly while server restarts\n\n💡 **PERFECT FOR:** 'restart the dev server', 'clean restart', 'reload the server' - but only when actually needed, not for regular code changes."
+    "🔄 **DEV SERVER RESTART** - Safely restarts the development server while preserving dev3000's monitoring, logs, and browser connection.\n\n🎯 **SMART RESTART LOGIC:**\n• First tries nextjs-dev MCP restart (if available and user has Next.js canary)\n• Falls back to dev3000's own restart mechanism:\n  - Kills the old server process on the app port\n  - Waits for clean shutdown\n  - Spawns a new server with the same command that was originally used\n  - Keeps dev3000's MCP server, browser monitoring, and screenshot capture running\n• All logging continues seamlessly - no data loss\n• Browser monitoring stays connected - no need to relaunch Chrome\n\n⚡ **WHEN TO USE:**\n• After modifying next.config.js, middleware, or environment variables\n• When you need a clean restart to clear server state\n• After significant code changes that Next.js HMR can't handle\n• When debugging persistent state or memory issues\n\n⚠️ **CRITICAL - DO NOT:**\n• ❌ NEVER manually run kill commands on the dev server like `pkill -f \"next dev\"` or `lsof -ti :3000 | xargs kill`\n• ❌ NEVER manually start the dev server with `npm run dev`, `pnpm dev`, `next dev`, etc.\n• ✅ ALWAYS use this tool for dev server restarts - it preserves all dev3000 infrastructure\n\n⚠️ **IMPORTANT:**\n• AVOID using this unnecessarily - Next.js HMR handles most changes automatically\n• Only restart when truly needed for config changes or state issues\n• The server will be offline for a few seconds during restart\n• Browser may show connection error briefly while server restarts\n\n💡 **PERFECT FOR:** 'restart the dev server', 'clean restart', 'reload the server' - but only when actually needed, not for regular code changes.",
+
+  crawl_app:
+    "🕷️ **APP CRAWLER** - Discovers all URLs in your app by crawling links starting from the homepage. Perfect for finding every page before running fixes or tests across your entire site.\n\n🎯 **SMART CRAWLING:**\n• Starts at your app's homepage (localhost)\n• Discovers all unique URLs at specified depth\n• Depth 1 = homepage links only\n• Depth 2 = homepage + links from those pages\n• Depth 'all' = exhaustive crawl until no new links found\n• Only follows same-origin links (stays within your app)\n• Deduplicates URLs automatically\n\n📊 **OUTPUT:**\n• List of all discovered URLs\n• Total count of unique pages\n• Depth reached\n• Ready to use with fix_my_app or other tools\n\n💡 **PERFECT FOR:**\n• 'crawl my app' or 'crawl my shit' - discover all pages\n• 'crawl my app and fix my shit' - find all pages then run fixes\n• Site-wide testing and debugging\n• Verifying all routes work before deployment\n\n⚡ **USAGE:**\n• Default: depth 1 (just homepage links)\n• Specify depth: 'crawl at depth 2' or depth=2\n• Full crawl: 'crawl all pages' or depth='all'"
 }
 
 // Types
@@ -46,6 +49,7 @@ export interface FixMyAppParams {
   integrateNextjs?: boolean
   integrateChromeDevtools?: boolean
   returnRawData?: boolean
+  createPR?: boolean // Create a PR for the highest priority issue
 }
 
 export interface CreateIntegratedWorkflowParams {
@@ -119,6 +123,259 @@ export interface StructuredAnalysisResult {
   }
 }
 
+export interface PrioritizedError {
+  error: string
+  category: "build" | "server" | "browser" | "network" | "warning"
+  severity: "critical" | "error" | "warning"
+  priorityScore: number
+  interactions: string[]
+  timestamp?: string
+  suggestedFix?: string
+}
+
+// Helper functions
+
+/**
+ * Calculate priority score for an error
+ * Higher score = higher priority to fix
+ *
+ * Scoring system:
+ * - Build errors: 1000+ (blocks development)
+ * - Server errors: 500+ (affects functionality)
+ * - Browser errors: 300+ (user-facing issues)
+ * - Network errors: 200+ (intermittent issues)
+ * - Warnings: 100+ (nice to fix)
+ *
+ * Additional modifiers:
+ * - Multiple occurrences: +50 per occurrence
+ * - Recent (last minute): +100
+ * - Has user interactions: +50 (reproducible)
+ */
+function calculateErrorPriority(
+  errorLine: string,
+  category: PrioritizedError["category"],
+  interactions: string[],
+  allErrors: string[]
+): number {
+  let score = 0
+
+  // Base score by category
+  if (category === "build") {
+    score = 1000
+  } else if (category === "server") {
+    score = 500
+  } else if (category === "browser") {
+    score = 300
+  } else if (category === "network") {
+    score = 200
+  } else if (category === "warning") {
+    score = 100
+  }
+
+  // Severity multipliers
+  if (/CRITICAL|FATAL|crashed/i.test(errorLine)) {
+    score *= 2
+  } else if (/ERROR|Exception|FAIL/i.test(errorLine)) {
+    score *= 1.5
+  }
+
+  // Count occurrences of similar errors
+  const errorPattern = errorLine.replace(/\d+/g, "\\d+").substring(0, 100)
+  const occurrences = allErrors.filter((e) => new RegExp(errorPattern).test(e)).length
+  if (occurrences > 1) {
+    score += (occurrences - 1) * 50
+  }
+
+  // Boost if has interactions (reproducible)
+  if (interactions.length > 0) {
+    score += 50
+  }
+
+  // Boost if recent (within last minute)
+  const timestampMatch = errorLine.match(/\[(\d{2}):(\d{2}):(\d{2})\.\d{3}\]/)
+  if (timestampMatch) {
+    const now = new Date()
+    const errorTime = new Date()
+    errorTime.setHours(parseInt(timestampMatch[1], 10))
+    errorTime.setMinutes(parseInt(timestampMatch[2], 10))
+    errorTime.setSeconds(parseInt(timestampMatch[3], 10))
+
+    const ageMinutes = (now.getTime() - errorTime.getTime()) / 1000 / 60
+    if (ageMinutes < 1) {
+      score += 100
+    }
+  }
+
+  return score
+}
+
+/**
+ * Find the single highest priority error from categorized errors
+ */
+function findHighestPriorityError(
+  categorizedErrors: {
+    serverErrors: string[]
+    browserErrors: string[]
+    buildErrors: string[]
+    networkErrors: string[]
+    warnings: string[]
+  },
+  allErrors: string[],
+  logLines: string[]
+): PrioritizedError | null {
+  const prioritizedErrors: PrioritizedError[] = []
+
+  // Helper to find interactions before an error
+  const findInteractions = (errorLine: string): string[] => {
+    const errorIndex = logLines.indexOf(errorLine)
+    if (errorIndex === -1) return []
+
+    const interactions: string[] = []
+    for (let i = errorIndex - 1; i >= Math.max(0, errorIndex - 20) && interactions.length < 5; i--) {
+      if (
+        logLines[i].includes("[INTERACTION]") ||
+        logLines[i].includes("[NAVIGATION]") ||
+        logLines[i].includes("[PAGE]")
+      ) {
+        interactions.unshift(logLines[i])
+      }
+    }
+    return interactions
+  }
+
+  // Process build errors
+  for (const error of categorizedErrors.buildErrors) {
+    const interactions = findInteractions(error)
+    prioritizedErrors.push({
+      error,
+      category: "build",
+      severity: "critical",
+      priorityScore: calculateErrorPriority(error, "build", interactions, allErrors),
+      interactions
+    })
+  }
+
+  // Process server errors
+  for (const error of categorizedErrors.serverErrors) {
+    const interactions = findInteractions(error)
+    const severity: PrioritizedError["severity"] = /CRITICAL|FATAL/i.test(error) ? "critical" : "error"
+    prioritizedErrors.push({
+      error,
+      category: "server",
+      severity,
+      priorityScore: calculateErrorPriority(error, "server", interactions, allErrors),
+      interactions
+    })
+  }
+
+  // Process browser errors
+  for (const error of categorizedErrors.browserErrors) {
+    const interactions = findInteractions(error)
+    const severity: PrioritizedError["severity"] = /CRITICAL|FATAL/i.test(error) ? "critical" : "error"
+    prioritizedErrors.push({
+      error,
+      category: "browser",
+      severity,
+      priorityScore: calculateErrorPriority(error, "browser", interactions, allErrors),
+      interactions
+    })
+  }
+
+  // Process network errors
+  for (const error of categorizedErrors.networkErrors) {
+    const interactions = findInteractions(error)
+    prioritizedErrors.push({
+      error,
+      category: "network",
+      severity: "error",
+      priorityScore: calculateErrorPriority(error, "network", interactions, allErrors),
+      interactions
+    })
+  }
+
+  // Process warnings (only if no errors found)
+  if (prioritizedErrors.length === 0) {
+    for (const error of categorizedErrors.warnings) {
+      const interactions = findInteractions(error)
+      prioritizedErrors.push({
+        error,
+        category: "warning",
+        severity: "warning",
+        priorityScore: calculateErrorPriority(error, "warning", interactions, allErrors),
+        interactions
+      })
+    }
+  }
+
+  // Sort by priority score (highest first)
+  prioritizedErrors.sort((a, b) => b.priorityScore - a.priorityScore)
+
+  return prioritizedErrors[0] || null
+}
+
+/**
+ * Create a PR for the highest priority issue
+ */
+async function createPRForIssue(prioritizedError: PrioritizedError, _projectName: string): Promise<string> {
+  try {
+    // Extract error details for PR title and body
+    const errorType = prioritizedError.category.toUpperCase()
+    const errorMessage = prioritizedError.error
+      .replace(/\[[^\]]+\]/g, "") // Remove timestamps and tags
+      .trim()
+      .substring(0, 100)
+
+    const prTitle = `Fix: ${errorType} - ${errorMessage}`
+
+    // Build PR body
+    const prBody = `## 🐛 Bug Fix - ${prioritizedError.category} Error
+
+**Priority Score:** ${prioritizedError.priorityScore} (${prioritizedError.severity})
+
+### Error Details
+\`\`\`
+${prioritizedError.error}
+\`\`\`
+
+${
+  prioritizedError.interactions.length > 0
+    ? `### Reproduction Steps
+The error occurred after these user interactions:
+${prioritizedError.interactions.map((i, idx) => `${idx + 1}. ${i}`).join("\n")}
+
+### Verification
+After implementing the fix, verify by:
+1. Replaying the same interactions using \`execute_browser_action\`
+2. Confirming the error no longer appears in logs
+3. Checking that functionality works as expected
+`
+    : ""
+}
+
+### Suggested Fix
+This PR addresses the ${prioritizedError.severity}-level ${prioritizedError.category} error detected by dev3000.
+
+${prioritizedError.suggestedFix || "Please analyze the error and implement the appropriate fix."}
+
+---
+🤖 Generated with [dev3000](https://github.com/vercel-labs/dev3000) - AI-powered debugging
+`
+
+    // Create a new branch
+    const branchName = `fix/${prioritizedError.category}-${Date.now()}`
+
+    // Use execAsync to run git and gh commands
+    await execAsync(`git checkout -b ${branchName}`)
+
+    // Create the PR using gh
+    await execAsync(`gh pr create --title "${prTitle}" --body "${prBody}" --head ${branchName}`)
+
+    return `✅ Created PR: ${prTitle}\n\nBranch: ${branchName}\n\nNext steps:\n1. Implement the fix in your code\n2. Commit and push changes\n3. PR is ready for review!`
+  } catch (error) {
+    return `❌ Failed to create PR: ${error instanceof Error ? error.message : String(error)}\n\nYou can manually create a PR with the error details above.`
+  }
+}
+
 // Helper functions
 export function findActiveSessions(): Session[] {
   const sessionDir = join(homedir(), ".d3k")
@@ -182,7 +439,8 @@ export async function fixMyApp({
   includeTimestampInstructions = true,
   integrateNextjs = false,
   integrateChromeDevtools = false,
-  returnRawData = false
+  returnRawData = false,
+  createPR = false
 }: FixMyAppParams): Promise<{ content: Array<{ type: "text"; text: string }> }> {
   // 🎯 MCP ORCHESTRATION: Check which downstream MCPs are available
   const { getMCPClientManager } = await import("./client-manager")
@@ -628,6 +886,47 @@ export async function fixMyApp({
           results.push("• Combined = 90%+ issue resolution rate!")
         }
       }
+
+      // 🎯 PRIORITIZATION & PR CREATION
+      // Find the single highest priority error and optionally create a PR
+      const highestPriorityError = findHighestPriorityError(categorizedErrors, actionableErrors, logLines)
+
+      if (highestPriorityError) {
+        results.push("")
+        results.push("🎯 **HIGHEST PRIORITY ISSUE:**")
+        results.push(`📊 Priority Score: ${highestPriorityError.priorityScore}`)
+        results.push(`🏷️ Category: ${highestPriorityError.category.toUpperCase()}`)
+        results.push(`⚠️ Severity: ${highestPriorityError.severity.toUpperCase()}`)
+        results.push("")
+        results.push("❌ **Error:**")
+        results.push(`   ${highestPriorityError.error}`)
+
+        if (highestPriorityError.interactions.length > 0) {
+          results.push("")
+          results.push("📍 **Reproduction Steps:**")
+          highestPriorityError.interactions.forEach((interaction, idx) => {
+            results.push(`   ${idx + 1}. ${interaction}`)
+          })
+        }
+
+        // Create PR if requested
+        if (createPR) {
+          results.push("")
+          results.push("🚀 **CREATING PR FOR THIS ISSUE...**")
+          const prResult = await createPRForIssue(highestPriorityError, projectName || "")
+          results.push(prResult)
+        } else {
+          results.push("")
+          results.push("💡 **To create a PR for this issue:**")
+          results.push("   Run: fix_my_app(createPR=true)")
+          results.push("")
+          results.push("   This will:")
+          results.push("   • Create a new branch for the fix")
+          results.push("   • Generate a PR with full error context")
+          results.push("   • Include reproduction steps")
+          results.push("   • Focus on fixing just this ONE issue")
+        }
+      }
     }
 
     // Extract screenshot information (replaces get_recent_screenshots)
@@ -3606,3 +3905,187 @@ export async function restartDevServer(params: {
     }
   }
 }
+
+// Crawl app - discover all URLs
+export interface CrawlAppParams {
+  depth?: number | "all"
+  projectName?: string
+}
+
+export async function crawlApp(params: CrawlAppParams) {
+  const { depth = 1, projectName } = params
+
+  try {
+    // Find active session
+    const sessions = findActiveSessions()
+    const session = projectName ? sessions.find((s) => s.projectName === projectName) : sessions[0]
+
+    if (!session) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: projectName
+              ? `❌ No active session found for project "${projectName}". Available projects: ${sessions.map((s) => s.projectName).join(", ") || "none"}`
+              : "❌ No active dev3000 sessions found. Start dev3000 first with `d3k` in your project directory."
+          }
+        ]
+      }
+    }
+
+    // Get CDP URL and app port from session
+    const sessionData = JSON.parse(readFileSync(session.sessionFile, "utf-8"))
+    const cdpUrl = sessionData.cdpUrl?.replace("http://", "ws://")
+    const appPort = sessionData.appPort || "3000"
+    const baseUrl = `http://localhost:${appPort}`
+
+    if (!cdpUrl) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: "❌ No Chrome DevTools connection found. Browser monitoring must be active to crawl."
+          }
+        ]
+      }
+    }
+
+    logToDevFile(`Crawl App: Starting crawl at depth ${depth} for ${baseUrl}`)
+
+    // Connect to CDP
+    const ws = new WebSocket(cdpUrl)
+    await new Promise((resolve, reject) => {
+      ws.on("open", resolve)
+      ws.on("error", reject)
+      setTimeout(() => reject(new Error("CDP connection timeout")), 5000)
+    })
+
+    let messageId = 2000
+    // biome-ignore lint/suspicious/noExplicitAny: CDP protocol responses are dynamic
+    const sendCommand = (method: string, params: Record<string, unknown> = {}): Promise<any> => {
+      return new Promise((resolve, reject) => {
+        const id = messageId++
+        const message = JSON.stringify({ id, method, params })
+
+        const handler = (data: Buffer) => {
+          const response = JSON.parse(data.toString())
+          if (response.id === id) {
+            ws.off("message", handler)
+            if (response.error) {
+              reject(new Error(response.error.message))
+            } else {
+              resolve(response.result)
+            }
+          }
+        }
+
+        ws.on("message", handler)
+        ws.send(message)
+
+        setTimeout(() => {
+          ws.off("message", handler)
+          reject(new Error("Command timeout"))
+        }, 10000)
+      })
+    }
+
+    // Enable necessary domains
+    await sendCommand("Runtime.enable")
+    await sendCommand("Page.enable")
+
+    // Discovered URLs
+    const discovered = new Set<string>([baseUrl])
+    const visited = new Set<string>()
+    const toVisit: string[] = [baseUrl]
+
+    let currentDepth = 0
+    const maxDepth = depth === "all" ? Number.POSITIVE_INFINITY : depth
+
+    while (toVisit.length > 0 && currentDepth <= maxDepth) {
+      const currentLevelUrls = [...toVisit]
+      toVisit.length = 0
+
+      logToDevFile(`Crawl App: Processing depth ${currentDepth} with ${currentLevelUrls.length} URLs`)
+
+      for (const url of currentLevelUrls) {
+        if (visited.has(url)) continue
+        visited.add(url)
+
+        try {
+          // Navigate to URL
+          logToDevFile(`Crawl App: Visiting ${url}`)
+          await sendCommand("Page.navigate", { url })
+
+          // Wait for page load
+          await new Promise((resolve) => setTimeout(resolve, 2000))
+
+          // Extract all links
+          const result = await sendCommand("Runtime.evaluate", {
+            expression: `
+              Array.from(document.querySelectorAll('a[href]')).map(a => {
+                try {
+                  const url = new URL(a.href, window.location.href);
+                  // Only return same-origin links
+                  if (url.origin === window.location.origin) {
+                    // Remove hash and query params for deduplication
+                    return url.origin + url.pathname;
+                  }
+                } catch {}
+                return null;
+              }).filter(Boolean)
+            `,
+            returnByValue: true
+          })
+
+          const links = result.result?.value || []
+
+          for (const link of links) {
+            if (!discovered.has(link)) {
+              discovered.add(link)
+              if (currentDepth < maxDepth) {
+                toVisit.push(link)
+              }
+            }
+          }
+
+          logToDevFile(`Crawl App: Found ${links.length} links on ${url}`)
+        } catch (error) {
+          logToDevFile(`Crawl App: Error visiting ${url} - ${error}`)
+        }
+      }
+
+      currentDepth++
+
+      // For "all" mode, stop when no new URLs are found
+      if (depth === "all" && toVisit.length === 0) {
+        break
+      }
+    }
+
+    ws.close()
+
+    const urls = Array.from(discovered).sort()
+    const depthReached = depth === "all" ? currentDepth - 1 : Math.min(currentDepth - 1, maxDepth)
+
+    logToDevFile(`Crawl App: Complete - discovered ${urls.length} URLs at depth ${depthReached}`)
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `🕷️ **APP CRAWL COMPLETE**\n\n📊 **SUMMARY:**\n• Base URL: ${baseUrl}\n• Depth: ${depthReached}${depth === "all" ? " (exhaustive)" : ""}\n• Total URLs: ${urls.length}\n\n📍 **DISCOVERED URLs:**\n${urls.map((url) => `• ${url}`).join("\n")}\n\n💡 **NEXT STEPS:**\n• Use fix_my_app to check for errors across all pages\n• Use execute_browser_action to test specific pages\n• Verify all routes are working correctly`
+        }
+      ]
+    }
+  } catch (error) {
+    logToDevFile(`Crawl App: Error - ${error}`)
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `❌ **CRAWL FAILED**\n\n${error instanceof Error ? error.message : String(error)}`
+        }
+      ]
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dev3000",
-  "version": "0.0.101",
+  "version": "0.0.103",
   "description": "AI-powered development tools with browser monitoring and MCP server integration",
   "type": "module",
   "main": "dist/index.js",
@@ -63,6 +63,7 @@
     "chalk": "^5.3.0",
     "commander": "^14.0.1",
     "ink": "^6.3.1",
+    "ink-spinner": "^5.0.0",
     "next": "16.0.0-canary.18",
     "ora": "^9.0.0",
     "package-manager-detector": "^1.3.0",

package/src/tui-interface-impl.tsx

@@ -1,6 +1,7 @@
 import chalk from "chalk"
 import { createReadStream, unwatchFile, watchFile } from "fs"
 import { Box, render, Text, useInput, useStdout } from "ink"
+import Spinner from "ink-spinner"
 import { useEffect, useRef, useState } from "react"
 import type { Readable } from "stream"
 import { LOG_COLORS } from "./constants/log-colors.js"
@@ -46,6 +47,7 @@ const TUIApp = ({
   const [scrollOffset, setScrollOffset] = useState(0)
   const [initStatus, setInitStatus] = useState<string | null>("Initializing...")
   const [appPort, setAppPort] = useState<string>(initialAppPort)
+  const [portConfirmed, setPortConfirmed] = useState<boolean>(false)
   const logIdCounter = useRef(0)
   const [clearFromLogId, setClearFromLogId] = useState<number>(0) // Track log ID to clear from
   const { stdout } = useStdout()
@@ -112,6 +114,7 @@ const TUIApp = ({
   useEffect(() => {
     onAppPortUpdate((port: string) => {
       setAppPort(port)
+      setPortConfirmed(true)
     })
   }, [onAppPortUpdate])
 
@@ -332,7 +335,10 @@ const TUIApp = ({
 
             {/* Info on the right */}
             <Box flexDirection="column" flexGrow={1}>
-              <Text color="cyan">🌐 App: http://localhost:{appPort}</Text>
+              <Box>
+                <Text color="cyan">🌐 App: http://localhost:{appPort} </Text>
+                {!portConfirmed && <Spinner type="dots" />}
+              </Box>
               <Text color="cyan">🤖 MCP: http://localhost:{mcpPort}</Text>
               <Text color="cyan">
                 📸 Logs: http://localhost:{mcpPort}/logs