dev3000 0.0.114 → 0.0.116

package/mcp-server/app/api/cloud/fix-workflow/steps.ts

@@ -4,11 +4,184 @@
  */
 
 import { put } from "@vercel/blob"
+import type { Sandbox } from "@vercel/sandbox"
 import { createGateway, generateText } from "ai"
 import { createD3kSandbox as createD3kSandboxUtil } from "@/lib/cloud/d3k-sandbox"
 
+/**
+ * Helper function to properly consume sandbox command output
+ * The Vercel Sandbox SDK returns a result object with an async logs() iterator
+ */
+async function runSandboxCommand(
+  sandbox: Sandbox,
+  cmd: string,
+  args: string[]
+): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+  const result = await sandbox.runCommand({ cmd, args })
+  let stdout = ""
+  let stderr = ""
+  for await (const log of result.logs()) {
+    if (log.stream === "stdout") {
+      stdout += log.data
+    } else {
+      stderr += log.data
+    }
+  }
+  await result.wait()
+  return { exitCode: result.exitCode, stdout, stderr }
+}
+
+/**
+ * Capture a screenshot using puppeteer-core inside the sandbox
+ * Returns the base64 encoded PNG image data and logs the page title
+ */
+async function captureScreenshotInSandbox(
+  sandbox: Sandbox,
+  appUrl: string,
+  chromiumPath: string,
+  label: string,
+  sandboxCwd = "/vercel/sandbox"
+): Promise<string | null> {
+  console.log(`[Screenshot] Capturing ${label} screenshot of ${appUrl}...`)
+
+  // Create a Node.js script to capture screenshot with puppeteer-core
+  // The script is placed in the sandbox cwd so it can find puppeteer-core from node_modules
+  // Output format: JSON with { title, screenshot } on first line, then base64 data
+  const screenshotScript = `
+const puppeteer = require('puppeteer-core');
+
+(async () => {
+  let browser;
+  try {
+    browser = await puppeteer.launch({
+      executablePath: '${chromiumPath}',
+      headless: true,
+      args: [
+        '--no-sandbox',
+        '--disable-setuid-sandbox',
+        '--disable-dev-shm-usage',
+        '--disable-gpu',
+        '--single-process'
+      ]
+    });
+
+    const page = await browser.newPage();
+    await page.setViewport({ width: 1280, height: 720 });
+
+    // Navigate with a reasonable timeout
+    await page.goto('${appUrl}', {
+      waitUntil: 'networkidle2',
+      timeout: 30000
+    });
+
+    // Get the page title for verification
+    const title = await page.title();
+    console.error('PAGE_TITLE:' + title);
+
+    // Wait a bit for any animations/layout shifts
+    await new Promise(r => setTimeout(r, 2000));
+
+    // Take screenshot as base64
+    const screenshot = await page.screenshot({
+      encoding: 'base64',
+      fullPage: false
+    });
+
+    console.log(screenshot);
+
+    await browser.close();
+  } catch (error) {
+    console.error('Screenshot error:', error.message);
+    if (browser) await browser.close();
+    process.exit(1);
+  }
+})();
+`
+
+  try {
+    // Write the script to the sandbox cwd so it can find puppeteer-core from node_modules
+    const scriptPath = `${sandboxCwd}/_screenshot.js`
+    const writeResult = await runSandboxCommand(sandbox, "sh", [
+      "-c",
+      `cat > ${scriptPath} << 'SCRIPT_EOF'
+${screenshotScript}
+SCRIPT_EOF`
+    ])
+
+    if (writeResult.exitCode !== 0) {
+      console.log(`[Screenshot] Failed to write script: ${writeResult.stderr}`)
+      return null
+    }
+
+    // Run the script from the sandbox directory so node can find puppeteer-core in node_modules
+    const screenshotResult = await sandbox.runCommand({
+      cmd: "node",
+      args: [scriptPath],
+      cwd: sandboxCwd
+    })
+
+    let stdout = ""
+    let stderr = ""
+    for await (const log of screenshotResult.logs()) {
+      if (log.stream === "stdout") {
+        stdout += log.data
+      } else {
+        stderr += log.data
+      }
+    }
+    await screenshotResult.wait()
+
+    // Extract page title from stderr (format: PAGE_TITLE:xxx)
+    const titleMatch = stderr.match(/PAGE_TITLE:(.*)/)
+    if (titleMatch) {
+      console.log(`[Screenshot] Page title: "${titleMatch[1]}"`)
+    }
+
+    if (screenshotResult.exitCode !== 0) {
+      console.log(`[Screenshot] Failed to capture: ${stderr}`)
+      return null
+    }
+
+    // The stdout should be the base64 image
+    const base64Data = stdout.trim()
+    if (base64Data && base64Data.length > 100) {
+      console.log(`[Screenshot] Captured ${label} screenshot (${base64Data.length} bytes base64)`)
+      return base64Data
+    }
+
+    console.log(`[Screenshot] No valid screenshot data returned`)
+    return null
+  } catch (error) {
+    console.log(`[Screenshot] Error: ${error instanceof Error ? error.message : String(error)}`)
+    return null
+  }
+}
+
+/**
+ * Upload a base64 screenshot to Vercel Blob
+ */
+async function uploadScreenshot(base64Data: string, label: string, projectName: string): Promise<string | null> {
+  try {
+    const imageBuffer = Buffer.from(base64Data, "base64")
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
+    const filename = `screenshot-${label}-${projectName}-${timestamp}.png`
+
+    const blob = await put(filename, imageBuffer, {
+      access: "public",
+      contentType: "image/png"
+    })
+
+    console.log(`[Screenshot] Uploaded ${label} screenshot: ${blob.url}`)
+    return blob.url
+  } catch (error) {
+    console.log(`[Screenshot] Upload failed: ${error instanceof Error ? error.message : String(error)}`)
+    return null
+  }
+}
+
 /**
  * Step 0: Create d3k sandbox with MCP tools pre-configured
+ * Also captures a "before" screenshot of the app
  */
 export async function createD3kSandbox(
   repoUrl: string,
@@ -48,34 +221,137 @@ export async function createD3kSandbox(
   console.log(`[Step 0] Dev URL: ${sandboxResult.devUrl}`)
   console.log(`[Step 0] MCP URL: ${sandboxResult.mcpUrl}`)
 
+  // Get the chromium path for screenshots
+  console.log(`[Step 0] Getting Chromium path for screenshots...`)
+  let chromiumPath = "/tmp/chromium"
+  try {
+    const chromiumResult = await runSandboxCommand(sandboxResult.sandbox, "node", [
+      "-e",
+      "require('@sparticuz/chromium').executablePath().then(p => console.log(p))"
+    ])
+    if (chromiumResult.exitCode === 0 && chromiumResult.stdout.trim()) {
+      chromiumPath = chromiumResult.stdout.trim()
+      console.log(`[Step 0] Chromium path: ${chromiumPath}`)
+    }
+  } catch {
+    console.log(`[Step 0] Could not get chromium path, using default: ${chromiumPath}`)
+  }
+
+  // CRITICAL DIAGNOSTIC: Test Chrome with EXACT d3k command
+  // d3k uses: --user-data-dir, no --remote-debugging-address, loading page, etc.
+  console.log(`[Step 0] ===== CHROMIUM CDP TEST (d3k exact command) =====`)
+  try {
+    const chromeTestScript = `
+      exec 2>&1
+      echo "=== Chromium CDP Test (d3k exact command) ==="
+      echo "Chromium path: ${chromiumPath}"
+      echo ""
+
+      # Create user-data-dir like d3k does
+      USER_DATA_DIR="/tmp/d3k-test-profile"
+      mkdir -p "$USER_DATA_DIR"
+      echo "1. Created user-data-dir: $USER_DATA_DIR"
+
+      # Create loading page like d3k does
+      LOADING_DIR="/tmp/dev3000-loading"
+      mkdir -p "$LOADING_DIR"
+      cat > "$LOADING_DIR/loading.html" << 'LOADINGHTML'
+<!DOCTYPE html>
+<html>
+<head><title>Loading...</title></head>
+<body><h1>Loading dev3000...</h1></body>
+</html>
+LOADINGHTML
+      echo "2. Created loading page: $LOADING_DIR/loading.html"
+      echo ""
+
+      # Use EXACT d3k command (from cdp-monitor.ts)
+      # Note: d3k does NOT use --remote-debugging-address
+      echo "3. Starting Chrome with d3k's exact args..."
+      echo "   Command: ${chromiumPath} --remote-debugging-port=9222 --user-data-dir=$USER_DATA_DIR --no-first-run --no-default-browser-check --disable-component-extensions-with-background-pages --disable-background-networking --disable-sync --metrics-recording-only --disable-default-apps --disable-session-crashed-bubble --disable-restore-session-state --headless=new --no-sandbox --disable-setuid-sandbox --disable-gpu --disable-dev-shm-usage file://$LOADING_DIR/loading.html"
+
+      timeout 15 "${chromiumPath}" \\
+        --remote-debugging-port=9222 \\
+        --user-data-dir="$USER_DATA_DIR" \\
+        --no-first-run \\
+        --no-default-browser-check \\
+        --disable-component-extensions-with-background-pages \\
+        --disable-background-networking \\
+        --disable-sync \\
+        --metrics-recording-only \\
+        --disable-default-apps \\
+        --disable-session-crashed-bubble \\
+        --disable-restore-session-state \\
+        --headless=new \\
+        --no-sandbox \\
+        --disable-setuid-sandbox \\
+        --disable-gpu \\
+        --disable-dev-shm-usage \\
+        "file://$LOADING_DIR/loading.html" &
+      PID=$!
+      echo "   Chrome PID: $PID"
+      sleep 3
+      echo ""
+
+      echo "4. Checking if Chrome is still running..."
+      if ps -p $PID > /dev/null 2>&1; then
+        echo "   Chrome is RUNNING after 3s"
+        echo ""
+        echo "5. Trying CDP (note: d3k doesn't use --remote-debugging-address)..."
+        echo "   Trying 127.0.0.1..."
+        curl -s --max-time 5 http://127.0.0.1:9222/json/version 2>&1 || echo "   127.0.0.1 failed"
+        echo ""
+        echo "   Trying localhost..."
+        curl -s --max-time 5 http://localhost:9222/json/version 2>&1 || echo "   localhost failed"
+        echo ""
+        echo "6. Checking what's listening on 9222..."
+        ss -tlnp 2>/dev/null | grep 9222 || netstat -tlnp 2>/dev/null | grep 9222 || echo "   Could not check listening ports"
+        echo ""
+        echo "7. Killing test Chrome..."
+        kill $PID 2>/dev/null
+      else
+        echo "   Chrome DIED within 3s"
+        wait $PID 2>/dev/null
+        EXIT_CODE=$?
+        echo "   Exit code: $EXIT_CODE"
+        echo ""
+        echo "   Checking for crash logs..."
+        ls -la "$USER_DATA_DIR" 2>&1 | head -10 || echo "   No user-data-dir"
+      fi
+      echo ""
+      echo "=== End d3k exact command test ==="
+    `
+    const chromeTest = await runSandboxCommand(sandboxResult.sandbox, "bash", ["-c", chromeTestScript])
+    console.log(`[Step 0] d3k Chrome test (exit ${chromeTest.exitCode}):\n${chromeTest.stdout || "(no output)"}`)
+    if (chromeTest.stderr) console.log(`[Step 0] d3k Chrome test stderr: ${chromeTest.stderr}`)
+  } catch (error) {
+    console.log(`[Step 0] d3k Chrome test error: ${error instanceof Error ? error.message : String(error)}`)
+  }
+  console.log(`[Step 0] ===== END d3k EXACT COMMAND TEST =====`)
+
+  // Capture "BEFORE" screenshot - this shows the app before any fixes
+  console.log(`[Step 0] Capturing BEFORE screenshot...`)
+  let beforeScreenshotUrl: string | null = null
+  try {
+    const beforeBase64 = await captureScreenshotInSandbox(
+      sandboxResult.sandbox,
+      "http://localhost:3000",
+      chromiumPath,
+      "before"
+    )
+    if (beforeBase64) {
+      beforeScreenshotUrl = await uploadScreenshot(beforeBase64, "before", projectName)
+    }
+  } catch (error) {
+    console.log(`[Step 0] Before screenshot failed: ${error instanceof Error ? error.message : String(error)}`)
+  }
+
   // Now capture CLS and errors using MCP from INSIDE the sandbox
-  // We must do this in Step 0 while we have the sandbox object
   console.log(`[Step 0] Capturing CLS metrics from inside sandbox...`)
 
   let clsData: unknown = null
   let mcpError: string | null = null
 
-  // Helper function to properly consume sandbox command output
-  // The Vercel Sandbox SDK returns a result object with an async logs() iterator
-  async function runSandboxCommand(
-    sandbox: typeof sandboxResult.sandbox,
-    cmd: string,
-    args: string[]
-  ): Promise<{ exitCode: number; stdout: string; stderr: string }> {
-    const result = await sandbox.runCommand({ cmd, args })
-    let stdout = ""
-    let stderr = ""
-    for await (const log of result.logs()) {
-      if (log.stream === "stdout") {
-        stdout += log.data
-      } else {
-        stderr += log.data
-      }
-    }
-    await result.wait()
-    return { exitCode: result.exitCode, stdout, stderr }
-  }
-
   try {
     // Call fix_my_app MCP tool via curl from inside the sandbox
     // This avoids network isolation issues - we're calling localhost:3684 from within the sandbox
@@ -156,6 +432,27 @@ export async function createD3kSandbox(
   }
   console.log(`[Step 0] === End sandbox log dump ===`)
 
+  // Capture git diff from sandbox - this shows any changes made by d3k
+  console.log(`[Step 0] Capturing git diff from sandbox...`)
+  let gitDiff: string | null = null
+  try {
+    const diffResult = await runSandboxCommand(sandboxResult.sandbox, "sh", [
+      "-c",
+      "cd /vercel/sandbox && git diff --no-color 2>/dev/null || echo 'No git diff available'"
+    ])
+    if (diffResult.exitCode === 0 && diffResult.stdout.trim() && diffResult.stdout.trim() !== "No git diff available") {
+      gitDiff = diffResult.stdout.trim()
+      console.log(`[Step 0] Git diff captured (${gitDiff.length} chars)`)
+      console.log(`[Step 0] Git diff preview:\n${gitDiff.substring(0, 500)}...`)
+    } else {
+      console.log(`[Step 0] No git changes detected in sandbox`)
+    }
+  } catch (diffError) {
+    console.log(
+      `[Step 0] Failed to capture git diff: ${diffError instanceof Error ? diffError.message : String(diffError)}`
+    )
+  }
+
   // Note: We cannot return the cleanup function or sandbox object as they're not serializable
   // Sandbox cleanup will happen automatically when the sandbox times out
   return {
@@ -163,7 +460,10 @@ export async function createD3kSandbox(
     devUrl: sandboxResult.devUrl,
     bypassToken: sandboxResult.bypassToken,
     clsData,
-    mcpError
+    mcpError,
+    beforeScreenshotUrl,
+    chromiumPath,
+    gitDiff
   }
 }
 
@@ -176,14 +476,18 @@ export async function fetchRealLogs(
   bypassToken?: string,
   sandboxDevUrl?: string,
   clsData?: unknown,
-  mcpError?: string | null
+  mcpError?: string | null,
+  beforeScreenshotUrlFromStep0?: string | null
 ) {
   "use step"
 
-  // If we already have CLS data from Step 0, use it
+  // If we already have CLS data from Step 0, use it along with the screenshot
   if (clsData) {
     console.log("[Step 1] Using CLS data captured in Step 0")
-    return { logAnalysis: JSON.stringify(clsData, null, 2), beforeScreenshotUrl: null }
+    if (beforeScreenshotUrlFromStep0) {
+      console.log(`[Step 1] Before screenshot from Step 0: ${beforeScreenshotUrlFromStep0}`)
+    }
+    return { logAnalysis: JSON.stringify(clsData, null, 2), beforeScreenshotUrl: beforeScreenshotUrlFromStep0 || null }
   }
 
   // If there was an MCP error in Step 0, log it
@@ -573,7 +877,13 @@ Format your response as a clear, structured report that helps identify what's br
       const response = await fetch(urlWithBypass, { method: "GET", headers })
       const body = await response.text()
 
+      // Extract and log page title from HTML
+      const titleMatch = body.match(/<title[^>]*>([^<]*)<\/title>/i)
+      const pageTitle = titleMatch ? titleMatch[1].trim() : "(no title found)"
+      console.log(`[Step 1] HTTP fallback - Page title: "${pageTitle}"`)
+
       let logAnalysis = `Dev Server URL: ${devUrl}\n`
+      logAnalysis += `Page Title: ${pageTitle}\n`
       logAnalysis += `HTTP Status: ${response.status} ${response.statusText}\n\n`
       logAnalysis += `Note: Browser automation failed, using fallback HTTP fetch.\n\n`
 
@@ -685,7 +995,8 @@ export async function uploadToBlob(
   projectName: string,
   logAnalysis: string,
   devUrl: string,
-  beforeScreenshotUrl?: string | null
+  beforeScreenshotUrl?: string | null,
+  gitDiff?: string | null
 ) {
   "use step"
 
@@ -693,6 +1004,9 @@ export async function uploadToBlob(
   if (beforeScreenshotUrl) {
     console.log(`[Step 3] Including before screenshot: ${beforeScreenshotUrl}`)
   }
+  if (gitDiff) {
+    console.log(`[Step 3] Including git diff (${gitDiff.length} chars)`)
+  }
 
   // Create screenshot section if we have a screenshot
   const screenshotSection = beforeScreenshotUrl
@@ -704,6 +1018,21 @@ This screenshot was captured when the sandbox dev server first loaded, proving t
 
 ---
 
+`
+    : ""
+
+  // Create git diff section if we have a diff from the sandbox
+  const gitDiffSection = gitDiff
+    ? `## Actual Git Diff from Sandbox
+
+The following diff shows the actual changes made by d3k in the sandbox environment:
+
+\`\`\`diff
+${gitDiff}
+\`\`\`
+
+---
+
 `
     : ""
 
@@ -712,12 +1041,14 @@ This screenshot was captured when the sandbox dev server first loaded, proving t
   const enhancedMarkdown = `# Fix Proposal for ${projectName}
 
 **Generated**: ${timestamp}
+
 **Powered by**: [dev3000](https://github.com/vercel-labs/dev3000) with Claude Code
+
 **Dev Server**: ${devUrl}
 
 ---
 
-${screenshotSection}## Original Log Analysis
+${screenshotSection}${gitDiffSection}## Original Log Analysis
 
 \`\`\`
 ${logAnalysis}

package/mcp-server/app/api/cloud/fix-workflow/workflow.ts

@@ -57,13 +57,16 @@ export async function cloudFixWorkflow(params: {
   console.log(`[Workflow] VERCEL_OIDC_TOKEN available: ${!!vercelOidcToken}`)
 
   // Step 0: Create d3k sandbox if repoUrl provided
-  // This step also captures CLS data from inside the sandbox
+  // This step also captures CLS data, "before" screenshot, and git diff from inside the sandbox
   let sandboxInfo: {
     mcpUrl: string
     devUrl: string
     bypassToken?: string
     clsData?: unknown
     mcpError?: string | null
+    beforeScreenshotUrl?: string | null
+    chromiumPath?: string
+    gitDiff?: string | null
   } | null = null
   if (repoUrl) {
     sandboxInfo = await createD3kSandbox(repoUrl, repoBranch || "main", projectName, vercelToken, vercelOidcToken)
@@ -72,26 +75,29 @@ export async function cloudFixWorkflow(params: {
   // Step 1: Fetch real logs (using sandbox MCP if available, otherwise devUrl directly)
   // If we got CLS data from Step 0, pass it to Step 1 to avoid re-fetching
   // Use bypass token from sandbox if available, otherwise use provided one
+  // Also pass the beforeScreenshotUrl from Step 0 if available
   const effectiveBypassToken = sandboxInfo?.bypassToken || bypassToken
   const step1Result = await fetchRealLogs(
     sandboxInfo?.mcpUrl || devUrl,
     effectiveBypassToken,
     sandboxInfo?.devUrl,
     sandboxInfo?.clsData,
-    sandboxInfo?.mcpError
+    sandboxInfo?.mcpError,
+    sandboxInfo?.beforeScreenshotUrl
   )
   const { logAnalysis, beforeScreenshotUrl } = step1Result
 
   // Step 2: Invoke AI agent to analyze logs and create fix
   const fixProposal = await analyzeLogsWithAgent(logAnalysis, sandboxInfo?.devUrl || devUrl)
 
-  // Step 3: Upload to blob storage with full context and screenshot
+  // Step 3: Upload to blob storage with full context, screenshot, and git diff
   const blobResult = await uploadToBlob(
     fixProposal,
     projectName,
     logAnalysis,
     sandboxInfo?.devUrl || devUrl,
-    beforeScreenshotUrl
+    beforeScreenshotUrl,
+    sandboxInfo?.gitDiff
   )
 
   // Step 4: Create GitHub PR if repo info provided AND there are actual fixes to apply
@@ -130,11 +136,12 @@ async function fetchRealLogs(
   bypassToken?: string,
   sandboxDevUrl?: string,
   clsData?: unknown,
-  mcpError?: string | null
+  mcpError?: string | null,
+  beforeScreenshotUrlFromStep0?: string | null
 ): Promise<{ logAnalysis: string; beforeScreenshotUrl: string | null }> {
   "use step"
   const { fetchRealLogs } = await import("./steps")
-  return fetchRealLogs(mcpUrlOrDevUrl, bypassToken, sandboxDevUrl, clsData, mcpError)
+  return fetchRealLogs(mcpUrlOrDevUrl, bypassToken, sandboxDevUrl, clsData, mcpError, beforeScreenshotUrlFromStep0)
 }
 
 async function analyzeLogsWithAgent(logAnalysis: string, devUrl: string) {
@@ -148,11 +155,12 @@ async function uploadToBlob(
   projectName: string,
   logAnalysis: string,
   devUrl: string,
-  beforeScreenshotUrl?: string | null
+  beforeScreenshotUrl?: string | null,
+  gitDiff?: string | null
 ) {
   "use step"
   const { uploadToBlob } = await import("./steps")
-  return uploadToBlob(fixProposal, projectName, logAnalysis, devUrl, beforeScreenshotUrl)
+  return uploadToBlob(fixProposal, projectName, logAnalysis, devUrl, beforeScreenshotUrl, gitDiff)
 }
 
 async function createGitHubPR(

package/mcp-server/app/api/cloud/start-fix/route.ts

@@ -132,12 +132,12 @@ export async function POST(request: Request) {
         userId,
         projectName,
         timestamp: new Date().toISOString(),
-        status: "success",
+        status: "done",
         reportBlobUrl: result.blobUrl,
         prUrl: result.pr?.prUrl,
         beforeScreenshotUrl: result.beforeScreenshotUrl || undefined
       })
-      console.log(`[Start Fix] Updated workflow run metadata to success: ${runId}`)
+      console.log(`[Start Fix] Updated workflow run metadata to done: ${runId}`)
     }
 
     return Response.json(

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

@@ -3,61 +3,60 @@ import { NextResponse } from "next/server"
 // This endpoint extracts MCP tools documentation by parsing the route handler
 export async function GET() {
   try {
-    // Streamlined tool set - reduced from 10 tools to 2 for zero authorization friction!
     const tools = [
       {
         name: "fix_my_app",
         description:
-          "🔧 **THE ULTIMATE FIND→FIX→VERIFY MACHINE!** This isn't just debugging—it's MAGICAL problem-solving that FIXES your app! 🪄\n\n🔥 **INSTANT FIX POWERS:**\n• FINDS: Server errors, browser crashes, build failures, API issues, performance problems—EVERYTHING\n• FIXES: Provides EXACT code fixes with file locations and line numbers\n• GUIDES: Step-by-step implementation of fixes\n• VERIFIES: Ensures fixes actually resolve the issues\n\n🚀 **3 ACTION MODES:**\n• **FIX NOW** (default): \"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 instantly\n2️⃣ I provide EXACT FIXES with code\n3️⃣ You implement the fixes\n4️⃣ We VERIFY everything works\n\n🎪 **WHY THIS TOOL IS MAGIC:**\n• Goes beyond debugging to actual fixing\n• Provides copy-paste fix code\n• Works with 'fix my app' or 'debug my app'\n• Makes broken apps work again!\n• You become the fix-it hero!\n\n💡 **PRO TIPS:**\n• Say 'fix my app' for instant error resolution\n• Use execute_browser_action to verify fixes\n• This tool doesn't just find problems—it SOLVES them!",
-        category: "Error Fixing",
+          "Diagnoses application errors from dev3000 logs. Returns prioritized issues requiring fixes.\n\n**CRITICAL: Use in a loop until all errors are resolved:**\n1. DIAGNOSE: Call fix_my_app to get errors\n2. FIX: Fix the highest-priority error\n3. VERIFY: Call fix_my_app again to confirm fix worked\n4. REPEAT: Loop until no errors remain\n\n**This tool does NOT fix anything automatically.** You must read the output, fix issues, and call again to verify.\n\n**What it analyzes:** Server logs, browser console, network requests. Prioritizes by severity (build > server > browser > network > warnings).",
+        category: "Diagnostics",
         parameters: [
           {
             name: "focusArea",
             type: "string",
             optional: true,
-            description: "Specific area: 'build', 'runtime', 'network', 'ui', 'all' (default: 'all')"
+            description: "Area to analyze: 'build', 'runtime', 'network', 'ui', 'performance', 'all' (default: 'all')"
           },
           {
             name: "mode",
             type: "enum",
             optional: true,
-            description: "Fix mode: 'snapshot' (fix now), 'bisect' (fix regression), 'monitor' (fix continuously)"
+            description: "Analysis mode: 'snapshot', 'bisect', 'monitor'"
           },
           {
             name: "waitForUserInteraction",
             type: "boolean",
             optional: true,
-            description: "In bisect mode: capture timestamp, wait for user testing, then analyze (default: false)"
+            description: "In bisect mode: wait for user testing before analyzing (default: false)"
           },
           {
             name: "timeRangeMinutes",
             type: "number",
             optional: true,
-            description: "Minutes to analyze back from now (default: 10)"
+            description: "Minutes to analyze (default: 10)"
           },
           {
-            name: "includeTimestampInstructions",
+            name: "createPR",
             type: "boolean",
             optional: true,
-            description: "Show timestamp-based debugging instructions (default: true)"
+            description: "Create a PR branch for the highest-priority issue (default: false)"
           }
         ]
       },
       {
         name: "execute_browser_action",
         description:
-          "🪄 **SMART INTERACTION TESTING** - Use for targeted user workflow verification! 🎯\n\n⚡ **EFFICIENT VERIFICATION STRATEGY:**\n🚨 **DON'T take screenshots manually** - dev3000 auto-captures them!\n✅ **DO use this for:** click, navigate, scroll, type to reproduce user interactions\n✅ **DO verify fixes by:** reproducing the original error scenario, then check fix_my_app for verification\n\n🔥 **BROWSER ACTIONS:**\n• CLICK buttons/links → Test specific user interactions\n• NAVIGATE to pages → Reproduce user journeys  \n• SCROLL & TYPE → Simulate user workflows\n• EVALUATE JavaScript → Check app state (read-only)\n\n⚡ **OPTIMAL FIX VERIFICATION WORKFLOW:**\n1️⃣ fix_my_app finds issues + provides exact fixes\n2️⃣ You implement the fix code\n3️⃣ Use execute_browser_action to REPRODUCE the original interaction\n4️⃣ Run fix_my_app again to verify the fix worked\n\n🎯 **PERFECT FOR:**\n• Verifying fixes actually resolve the errors\n• Testing interactions after implementing fixes\n• Confirming forms work, buttons respond, etc.\n• Ensuring the app works correctly after fixes\n\n🚫 **AVOID:** Manual screenshot action (dev3000 auto-captures)\n✅ **USE:** Interaction reproduction + fix_my_app for verification\n\n🛡️ **SAFETY:** Safe operations only, read-only JS evaluation",
+          "Executes browser actions in the dev3000-managed Chrome instance.\n\n**Actions:**\n• click: Click at coordinates {x, y}\n• navigate: Go to a URL\n• scroll: Scroll by {x, y} pixels\n• type: Type text into focused element\n• evaluate: Execute JavaScript (read-only recommended)\n• screenshot: Capture current page\n\n**Use cases:**\n• Reproducing user interactions that triggered errors\n• Verifying fixes work correctly\n• Testing UI workflows\n\n**Note:** Screenshots are auto-captured on navigation and errors. Use this for interaction reproduction, not manual screenshots.",
         category: "Browser Automation",
         parameters: [
           {
             name: "action",
             type: "enum",
-            description: "Action to perform: 'click', 'navigate', 'screenshot', 'evaluate', 'scroll', 'type'"
+            description: "Action: 'click', 'navigate', 'screenshot', 'evaluate', 'scroll', 'type'"
           },
           {
             name: "params",
             type: "object",
-            description: "Parameters for the action (coordinates, URL, selector, text, expression, etc.)"
+            description: "Action parameters (coordinates, URL, text, expression, etc.)"
           }
         ]
       }