@chinchillaenterprises/mcp-dev-logger 2.3.3 → 3.0.0

package/dist/index.js

@@ -4,2131 +4,316 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { ListToolsRequestSchema, CallToolRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { spawn, exec } from "child_process";
-import { writeFileSync, readFileSync, existsSync, appendFileSync, copyFileSync, readdirSync, statSync, mkdirSync, rmSync } from "fs";
-import { join, resolve } from "path";
-import { tmpdir } from "os";
+import { writeFileSync, existsSync, appendFileSync, mkdirSync, readFileSync } from "fs";
+import { join } from "path";
 import { promisify } from "util";
-import { chromium } from "playwright";
 const execAsync = promisify(exec);
-// Schema definitions
-const StartLogStreamingArgsSchema = z.object({
-    command: z.string().optional().describe("Dev command to run (default: npm run dev)"),
-    outputFile: z.string().optional().describe("File to write logs to (DEPRECATED: use structuredLogging instead)"),
-    cwd: z.string().optional().describe("Working directory"),
-    env: z.record(z.string()).optional().describe("Environment variables"),
-    processId: z.string().optional().describe("Custom process ID (auto-generated if not provided)"),
-    structuredLogging: z.boolean().optional().describe("Use organized logging with date-based sessions (default: true)"),
-    sessionDate: z.string().optional().describe("Session date for organized logging (YYYY-MM-DD, defaults to today)"),
-    logType: z.enum(["frontend", "backend", "amplify", "custom"]).optional().describe("Process type for standardized naming (auto-detected if not provided)")
+// Simple schema - no parameters needed
+const StartSandboxArgsSchema = z.object({});
+const StopSandboxArgsSchema = z.object({});
+const TailSandboxLogsArgsSchema = z.object({
+    lines: z.number().optional().describe("Number of lines to return (default: 50)")
 });
-const StopLogStreamingArgsSchema = z.object({
-    processId: z.string().optional().describe("Process ID to stop (if not provided, stops all processes)")
-});
-const RestartLogStreamingArgsSchema = z.object({
-    processId: z.string().describe("Process ID to restart"),
-    clearLogs: z.boolean().optional().describe("Clear logs on restart (default: false)")
-});
-const TailLogsArgsSchema = z.object({
-    processId: z.string().optional().describe("Process ID to tail logs from (if not provided, tries to find single process)"),
-    lines: z.number().optional().describe("Number of lines to return (default: 50)"),
-    filter: z.string().optional().describe("Grep pattern to filter logs")
-});
-const ClearLogsArgsSchema = z.object({
-    processId: z.string().optional().describe("Process ID to clear logs for (if not provided, tries to find single process)"),
-    backup: z.boolean().optional().describe("Backup logs before clearing (default: false)")
-});
-const GetProcessesArgsSchema = z.object({
-    processId: z.string().optional().describe("Process ID to get info for (if not provided, shows all processes)"),
-    format: z.enum(["raw", "formatted"]).optional().describe("Output format: raw (milliseconds) or formatted (hours/minutes/seconds) - default: formatted")
-});
-const CheckRunningProcessesArgsSchema = z.object({
-    processType: z.enum(["frontend", "backend", "amplify", "custom"]).optional().describe("Type of process to check for conflicts"),
-    port: z.number().optional().describe("Specific port to check")
-});
-const DiscoverLogsArgsSchema = z.object({
-    sessionDate: z.string().optional().describe("Specific session date (YYYY-MM-DD) to discover logs for (defaults to most recent)")
-});
-const StartFrontendWithBrowserArgsSchema = z.object({
-    command: z.string().optional().describe("Dev command to run (default: npm run dev)"),
-    port: z.number().optional().describe("Port to wait for (default: auto-detect from output)"),
-    waitTimeout: z.number().optional().describe("Max time to wait for server in ms (default: 30000)"),
-    browserDelay: z.number().optional().describe("Delay after server ready in ms (default: 1000)"),
-    teachingMode: z.boolean().optional().describe("Enable teaching features (default: true)"),
-    processId: z.string().optional().describe("Custom process ID (default: frontend-with-browser)"),
-    env: z.record(z.string()).optional().describe("Environment variables"),
-    cwd: z.string().optional().describe("Working directory")
-});
-class DevLoggerServer {
-    server;
-    activeServers;
-    pidFile;
-    constructor() {
-        this.server = new Server({
-            name: "mcp-dev-logger",
-            version: "1.0.0",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.activeServers = new Map();
-        this.pidFile = join(tmpdir(), "mcp-dev-logger.json");
-        // Load any saved state
-        this.loadState();
-        this.setupHandlers();
+const HARDCODED_COMMAND = "npx ampx sandbox --stream-function-logs";
+let sandboxProcess = null;
+// Get log file path - always in resources/sandbox/sandbox.log relative to cwd
+function getLogFilePath() {
+    const cwd = process.cwd();
+    const sandboxDir = join(cwd, "resources", "sandbox");
+    // Create resources/sandbox directory if it doesn't exist
+    if (!existsSync(sandboxDir)) {
+        mkdirSync(sandboxDir, { recursive: true });
     }
-    loadState() {
-        try {
-            if (existsSync(this.pidFile)) {
-                const data = JSON.parse(readFileSync(this.pidFile, 'utf8'));
-                // Note: We can't restore the actual process objects, but we can track that they existed
-                console.error("Previous dev server sessions detected. Use dev_get_status to check.");
+    return join(sandboxDir, "sandbox.log");
+}
+// Find existing sandbox process for current directory
+async function findExistingSandbox() {
+    const currentDir = process.cwd();
+    try {
+        // Get all ampx sandbox processes
+        const { stdout } = await execAsync("ps aux | grep 'ampx sandbox' | grep -v grep");
+        if (!stdout.trim()) {
+            return null; // No sandboxes running
+        }
+        // Extract PIDs from ps output
+        const lines = stdout.trim().split('\n');
+        const pids = [];
+        for (const line of lines) {
+            const match = line.match(/^\S+\s+(\d+)/);
+            if (match) {
+                pids.push(parseInt(match[1]));
             }
         }
-        catch (error) {
-            // Ignore errors loading state
-        }
-    }
-    saveState() {
-        try {
-            const state = {};
-            for (const [id, info] of this.activeServers) {
-                state[id] = {
-                    command: info.command,
-                    cwd: info.cwd,
-                    outputFile: info.outputFile,
-                    startTime: info.startTime,
-                    pid: info.pid,
-                    processId: info.processId
-                };
+        // Check each PID's working directory
+        for (const pid of pids) {
+            try {
+                const { stdout: lsofOutput } = await execAsync(`lsof -a -d cwd -p ${pid} 2>/dev/null | tail -1`);
+                // Extract path from lsof output (fields 9 onwards)
+                const fields = lsofOutput.trim().split(/\s+/);
+                const pathFields = fields.slice(8); // Starting from index 8 (field 9 in 1-indexed)
+                const workingDir = pathFields.join(' ').trim();
+                if (workingDir === currentDir) {
+                    return pid; // Found our sandbox!
+                }
+            }
+            catch (err) {
+                // Process might have exited, continue checking others
+                continue;
             }
-            writeFileSync(this.pidFile, JSON.stringify(state, null, 2));
-        }
-        catch (error) {
-            // Ignore errors saving state
         }
+        return null; // No sandbox found for this directory
     }
-    generateProcessId(command, outputFile) {
-        // Create a readable process ID based on command and output file
-        const commandPart = command.split(' ')[0].replace(/[^a-zA-Z0-9]/g, '');
-        const filePart = outputFile.split('/').pop()?.replace(/[^a-zA-Z0-9]/g, '').replace(/\.(txt|log)$/, '') || 'default';
-        return `${commandPart}-${filePart}`;
-    }
-    findProcessOrDefault(processId) {
-        if (processId) {
-            return this.activeServers.has(processId) ? processId : null;
-        }
-        // If no processId provided and only one process running, use that
-        const activeIds = Array.from(this.activeServers.keys());
-        if (activeIds.length === 1) {
-            return activeIds[0];
-        }
+    catch (err) {
+        // No processes found or error occurred
         return null;
     }
-    async checkPortInUse(port) {
+}
+// Start Amplify sandbox with streaming logs
+async function startSandbox() {
+    // Check for existing sandbox process in this directory
+    const existingPid = await findExistingSandbox();
+    const logFile = getLogFilePath();
+    let killedPid;
+    if (existingPid) {
+        // Found existing sandbox, kill it first
         try {
-            // Use lsof to check what's using the port
-            const { stdout } = await execAsync(`lsof -i :${port} -P -t`);
-            const pid = parseInt(stdout.trim());
-            if (pid) {
-                // Get command for this PID
-                try {
-                    const { stdout: cmdStdout } = await execAsync(`ps -p ${pid} -o command=`);
-                    return {
-                        inUse: true,
-                        pid: pid,
-                        command: cmdStdout.trim()
-                    };
-                }
-                catch {
-                    return { inUse: true, pid: pid };
-                }
-            }
+            process.kill(existingPid, 'SIGTERM');
+            killedPid = existingPid;
+            const timestamp = new Date().toISOString();
+            appendFileSync(logFile, `[${timestamp}] Killed existing sandbox (PID: ${existingPid}), starting fresh...\n`, "utf-8");
+            // Wait a bit for cleanup
+            await new Promise(resolve => setTimeout(resolve, 2000));
         }
-        catch (error) {
-            // Port is not in use or lsof failed
+        catch (err) {
+            // Process might already be dead, continue anyway
         }
-        return { inUse: false };
-    }
-    detectProcessType(command) {
-        const cmd = command.toLowerCase();
-        if (cmd.includes('next dev') || cmd.includes('npm run dev') || cmd.includes('yarn dev') || cmd.includes('pnpm dev') || cmd.includes('vite')) {
-            return 'frontend';
-        }
-        if (cmd.includes('ampx sandbox') || cmd.includes('amplify sandbox')) {
-            return 'amplify';
-        }
-        if (cmd.includes('node server') || cmd.includes('express') || cmd.includes('fastify') || cmd.includes('api')) {
-            return 'backend';
-        }
-        return 'custom';
-    }
-    getCommonPorts(processType) {
-        switch (processType) {
-            case 'frontend':
-                return [3000, 3001, 5173, 5174, 8080, 8081];
-            case 'backend':
-                return [3001, 8000, 8080, 4000, 5000];
-            case 'amplify':
-                return []; // Amplify doesn't typically use fixed ports
-            default:
-                return [3000, 3001, 5173, 5174, 8000, 8080, 8081, 4000, 5000];
+        // Clear our tracked process if it was the one we killed
+        if (sandboxProcess?.pid === existingPid) {
+            sandboxProcess = null;
         }
     }
-    async checkRunningProcesses(processType, specificPort) {
-        const conflicts = [];
-        const recommendations = [];
-        // Ports to check
-        const portsToCheck = specificPort ? [specificPort] : this.getCommonPorts(processType);
-        // Check each port
-        for (const port of portsToCheck) {
-            const portCheck = await this.checkPortInUse(port);
-            if (portCheck.inUse) {
-                const detectedType = portCheck.command ? this.detectProcessType(portCheck.command) : 'unknown';
-                conflicts.push({
-                    port: port,
-                    pid: portCheck.pid || 0,
-                    command: portCheck.command || 'Unknown process',
-                    processType: detectedType
-                });
-                recommendations.push(`Port ${port} is busy with ${detectedType} server (PID ${portCheck.pid})`);
+    // Start new sandbox
+    // Clear/overwrite the log file
+    writeFileSync(logFile, "", "utf-8");
+    // Write initial log entry
+    const timestamp = new Date().toISOString();
+    appendFileSync(logFile, `[${timestamp}] Starting Amplify sandbox: ${HARDCODED_COMMAND}\n`, "utf-8");
+    // Start the process
+    const cwd = process.cwd();
+    const proc = spawn("npx", ["ampx", "sandbox", "--stream-function-logs"], {
+        cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: false,
+        shell: false
+    });
+    sandboxProcess = {
+        process: proc,
+        pid: proc.pid,
+        startTime: new Date()
+    };
+    // Stream stdout to log file
+    proc.stdout?.on("data", (data) => {
+        const timestamp = new Date().toISOString();
+        const lines = data.toString().split("\n");
+        lines.forEach(line => {
+            if (line.trim()) {
+                appendFileSync(logFile, `[${timestamp}] ${line}\n`, "utf-8");
             }
-        }
-        // Find available ports
-        const allCommonPorts = [3000, 3001, 3002, 5173, 5174, 8000, 8080, 8081, 4000, 5000];
-        const busyPorts = conflicts.map(c => c.port);
-        const availablePorts = allCommonPorts.filter(port => !busyPorts.includes(port));
-        // Add recommendations
-        if (conflicts.length > 0 && availablePorts.length > 0) {
-            recommendations.push(`Consider using port ${availablePorts[0]} instead`);
-            recommendations.push(`Or stop the existing process first`);
-        }
-        if (conflicts.length === 0) {
-            recommendations.push('No conflicts detected - safe to start new processes');
-        }
+        });
+    });
+    // Stream stderr to log file
+    proc.stderr?.on("data", (data) => {
+        const timestamp = new Date().toISOString();
+        const lines = data.toString().split("\n");
+        lines.forEach(line => {
+            if (line.trim()) {
+                appendFileSync(logFile, `[${timestamp}] [ERROR] ${line}\n`, "utf-8");
+            }
+        });
+    });
+    // Handle process exit
+    proc.on("exit", (code, signal) => {
+        const timestamp = new Date().toISOString();
+        appendFileSync(logFile, `[${timestamp}] Amplify sandbox exited with code ${code} and signal ${signal}\n`, "utf-8");
+        sandboxProcess = null;
+    });
+    proc.on("error", (err) => {
+        const timestamp = new Date().toISOString();
+        appendFileSync(logFile, `[${timestamp}] [ERROR] Failed to start Amplify sandbox: ${err.message}\n`, "utf-8");
+        sandboxProcess = null;
+    });
+    const message = killedPid
+        ? `Killed existing sandbox (PID: ${killedPid}) and started fresh. Logs are being written to ${logFile}`
+        : `Amplify sandbox started. Logs are being written to ${logFile}`;
+    return {
+        success: true,
+        message,
+        logFile,
+        killedPid
+    };
+}
+// Stop Amplify sandbox
+function stopSandbox() {
+    if (!sandboxProcess?.process) {
         return {
-            status: 'success',
-            conflicts,
-            availablePorts: availablePorts.slice(0, 5), // Limit to first 5 available
-            recommendations
+            success: false,
+            message: "No Amplify sandbox process is running."
         };
     }
-    detectLogProcessType(fileName) {
-        const name = fileName.toLowerCase();
-        if (name.includes('frontend') || name.includes('next') || name.includes('react') || name.includes('vite')) {
-            return 'frontend';
-        }
-        if (name.includes('backend') || name.includes('api') || name.includes('server')) {
-            return 'backend';
-        }
-        if (name.includes('amplify') || name.includes('ampx')) {
-            return 'amplify';
-        }
-        return 'custom';
-    }
-    getLogFilesFromDirectory(dirPath) {
-        if (!existsSync(dirPath)) {
-            return [];
-        }
-        const logFiles = [];
-        try {
-            const files = readdirSync(dirPath);
-            for (const file of files) {
-                // Skip non-log files and hidden files
-                if (!file.endsWith('.log') && !file.endsWith('.txt') || file.startsWith('.')) {
-                    continue;
-                }
-                const filePath = join(dirPath, file);
-                const stats = statSync(filePath);
-                // Get line count for log files
-                let lineCount;
-                try {
-                    const content = readFileSync(filePath, 'utf8');
-                    lineCount = content.split('\n').filter(line => line.trim()).length;
-                }
-                catch {
-                    // Ignore errors reading file content
-                }
-                logFiles.push({
-                    fileName: file,
-                    filePath: filePath,
-                    processType: this.detectLogProcessType(file),
-                    size: stats.size,
-                    lastModified: stats.mtime,
-                    lineCount
-                });
-            }
-        }
-        catch (error) {
-            // Directory read error - return empty array
-        }
-        return logFiles.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+    const logFile = getLogFilePath();
+    const timestamp = new Date().toISOString();
+    appendFileSync(logFile, `[${timestamp}] Stopping Amplify sandbox...\n`, "utf-8");
+    try {
+        sandboxProcess.process.kill("SIGTERM");
+        sandboxProcess = null;
+        return {
+            success: true,
+            message: "Amplify sandbox stopped successfully."
+        };
     }
-    async discoverLogs(sessionDate) {
-        const cwd = process.cwd();
-        const logsDir = join(cwd, 'logs');
-        // If logs directory doesn't exist, check current directory for log files
-        if (!existsSync(logsDir)) {
-            const currentDirLogs = this.getLogFilesFromDirectory(cwd);
-            if (currentDirLogs.length === 0) {
-                return {
-                    status: 'no_logs_found',
-                    availableSessions: [],
-                    recommendedLogs: ['No log files found. Start a dev server to create logs.'],
-                    totalSessions: 0
-                };
-            }
-            // Return current directory logs as a session
-            return {
-                status: 'success',
-                mostRecentSession: {
-                    sessionDate: new Date().toISOString().split('T')[0],
-                    logFiles: currentDirLogs,
-                    totalFiles: currentDirLogs.length,
-                    sessionPath: cwd
-                },
-                availableSessions: ['current'],
-                recommendedLogs: currentDirLogs.map(f => `${f.processType}: ${f.fileName} (${f.lineCount || 0} lines)`),
-                totalSessions: 1
-            };
-        }
-        // Discover date-based sessions in logs directory
-        const sessions = [];
-        let mostRecentSession;
-        try {
-            const entries = readdirSync(logsDir);
-            for (const entry of entries) {
-                const entryPath = join(logsDir, entry);
-                const stats = statSync(entryPath);
-                if (stats.isDirectory() && /^\d{4}-\d{2}-\d{2}$/.test(entry)) {
-                    sessions.push(entry);
-                }
-            }
-            // Sort sessions by date (most recent first)
-            sessions.sort((a, b) => b.localeCompare(a));
-            // Get the target session (specified or most recent)
-            const targetSession = sessionDate || sessions[0];
-            if (targetSession && sessions.includes(targetSession)) {
-                const sessionPath = join(logsDir, targetSession);
-                const logFiles = this.getLogFilesFromDirectory(sessionPath);
-                mostRecentSession = {
-                    sessionDate: targetSession,
-                    logFiles,
-                    totalFiles: logFiles.length,
-                    sessionPath
-                };
-            }
-        }
-        catch (error) {
-            // Directory read error
-        }
-        const recommendedLogs = [];
-        if (mostRecentSession) {
-            if (mostRecentSession.logFiles.length === 0) {
-                recommendedLogs.push(`Session ${mostRecentSession.sessionDate} has no log files`);
-            }
-            else {
-                recommendedLogs.push(`Most recent session: ${mostRecentSession.sessionDate}`);
-                recommendedLogs.push(...mostRecentSession.logFiles.map(f => `${f.processType}: ${f.fileName} (${f.lineCount || 0} lines, ${Math.round(f.size / 1024)}KB)`));
-            }
-        }
-        else if (sessions.length === 0) {
-            recommendedLogs.push('No organized log sessions found. Logs will be created in logs/YYYY-MM-DD/ when you start dev servers.');
-        }
-        else {
-            recommendedLogs.push('No logs found in recent sessions. Start dev servers to generate logs.');
-        }
+    catch (err) {
         return {
-            status: sessions.length > 0 ? 'success' : 'no_sessions_found',
-            mostRecentSession,
-            availableSessions: sessions,
-            recommendedLogs,
-            totalSessions: sessions.length
+            success: false,
+            message: `Failed to stop Amplify sandbox: ${err instanceof Error ? err.message : String(err)}`
         };
     }
-    createStructuredLogPath(command, sessionDate, logType) {
-        const cwd = process.cwd();
-        const today = new Date().toISOString().split('T')[0];
-        const targetDate = sessionDate || today;
-        // Create logs directory if it doesn't exist
-        const logsDir = join(cwd, 'logs');
-        const sessionDir = join(logsDir, targetDate);
-        if (!existsSync(logsDir)) {
-            mkdirSync(logsDir, { recursive: true });
-        }
-        if (!existsSync(sessionDir)) {
-            mkdirSync(sessionDir, { recursive: true });
-        }
-        // Determine log type and create process type subfolder
-        const detectedType = logType || this.detectProcessType(command);
-        const processTypeDir = join(sessionDir, detectedType);
-        if (!existsSync(processTypeDir)) {
-            mkdirSync(processTypeDir, { recursive: true });
-        }
-        // Generate standardized filename
-        const standardizedName = this.generateStandardizedLogName(detectedType, command);
-        return join(processTypeDir, standardizedName);
+}
+// Tail sandbox logs
+function tailSandboxLogs(lines = 50) {
+    const logFile = getLogFilePath();
+    if (!existsSync(logFile)) {
+        return {
+            success: false,
+            message: "No log file found. Start the sandbox first with dev_start_sandbox."
+        };
     }
-    generateStandardizedLogName(logType, command) {
-        // Standardized naming conventions without redundant prefixes
-        const timestamp = new Date().toTimeString().split(' ')[0].replace(/:/g, '-');
-        switch (logType) {
-            case 'frontend':
-                if (command.includes('next'))
-                    return `nextjs-${timestamp}.log`;
-                if (command.includes('vite'))
-                    return `vite-${timestamp}.log`;
-                if (command.includes('react'))
-                    return `react-${timestamp}.log`;
-                return `dev-${timestamp}.log`;
-            case 'backend':
-                if (command.includes('express'))
-                    return `express-${timestamp}.log`;
-                if (command.includes('fastify'))
-                    return `fastify-${timestamp}.log`;
-                if (command.includes('node'))
-                    return `node-${timestamp}.log`;
-                return `api-${timestamp}.log`;
-            case 'amplify':
-                if (command.includes('sandbox'))
-                    return `sandbox-${timestamp}.log`;
-                if (command.includes('deploy'))
-                    return `deploy-${timestamp}.log`;
-                return `dev-${timestamp}.log`;
-            default:
-                // Extract first word of command for custom processes
-                const cmdName = command.split(' ')[0].replace(/[^a-zA-Z0-9]/g, '');
-                return `${cmdName}-${timestamp}.log`;
-        }
+    try {
+        const content = readFileSync(logFile, "utf-8");
+        const allLines = content.split("\n").filter(line => line.trim());
+        const tailLines = allLines.slice(-lines);
+        return {
+            success: true,
+            logs: tailLines.join("\n")
+        };
     }
-    shouldUseStructuredLogging(args) {
-        // Use structured logging by default unless explicitly disabled
-        // or if legacy outputFile is provided without structuredLogging flag
-        if (args.structuredLogging === false)
-            return false;
-        if (args.outputFile && args.structuredLogging !== true)
-            return false;
-        return true;
+    catch (err) {
+        return {
+            success: false,
+            message: `Failed to read logs: ${err instanceof Error ? err.message : String(err)}`
+        };
     }
-    cleanupOldLogs(retentionDays = 3) {
-        try {
-            const cwd = process.cwd();
-            const logsDir = join(cwd, 'logs');
-            // Skip if logs directory doesn't exist
-            if (!existsSync(logsDir)) {
-                return;
+}
+// Initialize MCP server
+const server = new Server({
+    name: "mcp-dev-logger",
+    version: "3.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const tools = [
+        {
+            name: "dev_start_sandbox",
+            description: "Start Amplify Gen2 sandbox with streaming function logs. Runs 'npx ampx sandbox --stream-function-logs' and logs to resources/sandbox.log (overwrites previous logs).",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                required: []
+            }
+        },
+        {
+            name: "dev_stop_sandbox",
+            description: "Stop the running Amplify sandbox process.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                required: []
             }
-            const now = new Date();
-            const cutoffTime = now.getTime() - (retentionDays * 24 * 60 * 60 * 1000);
-            // Read all entries in logs directory
-            const entries = readdirSync(logsDir);
-            for (const entry of entries) {
-                // Check if it's a date folder (YYYY-MM-DD format)
-                if (/^\d{4}-\d{2}-\d{2}$/.test(entry)) {
-                    const entryPath = join(logsDir, entry);
-                    const stats = statSync(entryPath);
-                    if (stats.isDirectory()) {
-                        // Parse the date from folder name
-                        const folderDate = new Date(entry + 'T00:00:00');
-                        // If folder is older than retention period, remove it
-                        if (folderDate.getTime() < cutoffTime) {
-                            try {
-                                rmSync(entryPath, { recursive: true, force: true });
-                                console.error(`Cleaned up old log directory: ${entry}`);
-                            }
-                            catch (error) {
-                                console.error(`Failed to remove old log directory ${entry}:`, error);
-                            }
-                        }
+        },
+        {
+            name: "dev_tail_sandbox_logs",
+            description: "Get the last N lines from the sandbox log file.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    lines: {
+                        type: "number",
+                        description: "Number of lines to return (default: 50)"
                     }
-                }
+                },
+                required: []
             }
         }
-        catch (error) {
-            // Log cleanup failures shouldn't break the main functionality
-            console.error('Log cleanup error:', error);
-        }
-    }
-    async killAllProcesses() {
-        for (const [id, info] of this.activeServers) {
-            try {
-                // Close browser if running
-                if (info.browser) {
-                    await info.browser.close();
-                }
-                if (info.process) {
-                    // Remove all event listeners to prevent memory leaks
-                    info.process.stdout?.removeAllListeners('data');
-                    info.process.stderr?.removeAllListeners('data');
-                    info.process.removeAllListeners('exit');
-                    info.process.removeAllListeners('error');
-                    // Kill the process
-                    if (info.pid) {
-                        // Kill the process group (negative PID) to kill all children
-                        process.kill(-info.pid, 'SIGTERM');
-                    }
-                }
+    ];
+    return { tools };
+});
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "dev_start_sandbox": {
+                const result = await startSandbox();
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                };
             }
-            catch (error) {
-                // Process might already be dead, try individual PID
-                try {
-                    if (info.pid) {
-                        process.kill(info.pid, 'SIGTERM');
-                    }
-                }
-                catch (fallbackError) {
-                    // Ignore - process is definitely dead
-                }
+            case "dev_stop_sandbox": {
+                const result = stopSandbox();
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                };
             }
-        }
-        this.activeServers.clear();
-    }
-    setupHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            const tools = [
-                {
-                    name: "dev_start_log_streaming",
-                    description: "Start development server with organized logging (logs/YYYY-MM-DD/). Supports structured sessions and standardized file naming.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            command: {
-                                type: "string",
-                                description: "Dev command to run (default: npm run dev)"
-                            },
-                            outputFile: {
-                                type: "string",
-                                description: "File to write logs to (DEPRECATED: use structuredLogging instead)"
-                            },
-                            cwd: {
-                                type: "string",
-                                description: "Working directory"
-                            },
-                            env: {
-                                type: "object",
-                                description: "Environment variables",
-                                additionalProperties: {
-                                    type: "string"
-                                }
-                            },
-                            processId: {
-                                type: "string",
-                                description: "Custom process ID (auto-generated if not provided)"
-                            },
-                            structuredLogging: {
-                                type: "boolean",
-                                description: "Use organized logging with date-based sessions (default: true)"
-                            },
-                            sessionDate: {
-                                type: "string",
-                                description: "Session date for organized logging (YYYY-MM-DD, defaults to today)"
-                            },
-                            logType: {
-                                type: "string",
-                                enum: ["frontend", "backend", "amplify", "custom"],
-                                description: "Process type for standardized naming (auto-detected if not provided)"
-                            }
-                        }
-                    }
-                },
-                {
-                    name: "dev_get_processes",
-                    description: "Get information about running development processes with optional formatting",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            processId: {
-                                type: "string",
-                                description: "Process ID to get info for (if not provided, shows all processes)"
-                            },
-                            format: {
-                                type: "string",
-                                enum: ["raw", "formatted"],
-                                description: "Output format: raw (milliseconds) or formatted (hours/minutes/seconds) - default: formatted"
-                            }
-                        }
-                    }
-                },
-                {
-                    name: "dev_stop_log_streaming",
-                    description: "Stop development server(s) and logging",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            processId: {
-                                type: "string",
-                                description: "Process ID to stop (if not provided, stops all processes)"
-                            }
-                        }
-                    }
-                },
-                {
-                    name: "dev_restart_log_streaming",
-                    description: "Restart a specific development server",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            processId: {
-                                type: "string",
-                                description: "Process ID to restart"
-                            },
-                            clearLogs: {
-                                type: "boolean",
-                                description: "Clear logs on restart (default: false)"
-                            }
-                        },
-                        required: ["processId"]
-                    }
-                },
-                {
-                    name: "dev_tail_logs",
-                    description: "Get last N lines from log file",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            processId: {
-                                type: "string",
-                                description: "Process ID to tail logs from (if not provided, tries to find single process)"
-                            },
-                            lines: {
-                                type: "number",
-                                description: "Number of lines to return (default: 50)"
-                            },
-                            filter: {
-                                type: "string",
-                                description: "Grep pattern to filter logs"
-                            }
-                        }
-                    }
-                },
-                {
-                    name: "dev_clear_logs",
-                    description: "Clear the log file",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            processId: {
-                                type: "string",
-                                description: "Process ID to clear logs for (if not provided, tries to find single process)"
-                            },
-                            backup: {
-                                type: "boolean",
-                                description: "Backup logs before clearing (default: false)"
-                            }
-                        }
-                    }
-                },
-                {
-                    name: "dev_check_running_processes",
-                    description: "Check for running development processes that might conflict with new servers",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            processType: {
-                                type: "string",
-                                enum: ["frontend", "backend", "amplify", "custom"],
-                                description: "Type of process to check for conflicts"
-                            },
-                            port: {
-                                type: "number",
-                                description: "Specific port to check"
-                            }
-                        }
-                    }
-                },
-                {
-                    name: "dev_discover_logs",
-                    description: "Auto-discover available log files and sessions in organized directory structure",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            sessionDate: {
-                                type: "string",
-                                description: "Specific session date (YYYY-MM-DD) to discover logs for (defaults to most recent)"
-                            }
-                        }
-                    }
-                },
-                {
-                    name: "dev_launch_test_browser",
-                    description: "Launch a TEST BROWSER for students to interact with. All console logs from this browser are captured automatically. Students should use THIS browser (not their regular browser) to test their app.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            processId: {
-                                type: "string",
-                                description: "Process ID to attach browser console to"
-                            },
-                            browserUrl: {
-                                type: "string",
-                                description: "URL to open in test browser (default: http://localhost:3000)"
-                            },
-                            teachingMode: {
-                                type: "boolean",
-                                description: "Enable teaching mode with DevTools open and slower actions (default: true)"
-                            },
-                            viewport: {
-                                type: "object",
-                                properties: {
-                                    width: { type: "number", default: 1920 },
-                                    height: { type: "number", default: 1080 }
-                                },
-                                description: "Browser window size"
-                            },
-                            highlightErrors: {
-                                type: "boolean",
-                                description: "Add visual indicator when console errors occur (default: true)"
-                            }
-                        }
-                    }
-                },
-                {
-                    name: "dev_stop_browser_console",
-                    description: "Stop browser console capture for a specific process",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            processId: {
-                                type: "string",
-                                description: "Process ID to stop browser console capture for"
-                            }
-                        }
-                    }
-                },
-                {
-                    name: "dev_start_frontend_with_browser",
-                    description: "🚀 ONE-CLICK STUDENT WORKFLOW: Start frontend server AND automatically launch test browser when ready. Perfect for teaching environments - reduces setup from 3 commands to 1. Browser launches with DevTools open, error highlighting, and all console logs captured.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            command: {
-                                type: "string",
-                                description: "Dev command to run (default: npm run dev)"
-                            },
-                            port: {
-                                type: "number",
-                                description: "Port to wait for (default: auto-detect from output)"
-                            },
-                            waitTimeout: {
-                                type: "number",
-                                description: "Max time to wait for server in ms (default: 30000)"
-                            },
-                            browserDelay: {
-                                type: "number",
-                                description: "Delay after server ready in ms (default: 1000)"
-                            },
-                            teachingMode: {
-                                type: "boolean",
-                                description: "Enable teaching features (default: true)"
-                            },
-                            processId: {
-                                type: "string",
-                                description: "Custom process ID (default: frontend-with-browser)"
-                            },
-                            env: {
-                                type: "object",
-                                description: "Environment variables"
-                            },
-                            cwd: {
-                                type: "string",
-                                description: "Working directory"
-                            }
-                        }
-                    }
-                }
-            ];
-            return { tools };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            try {
-                const { name, arguments: args } = request.params;
-                switch (name) {
-                    case "dev_start_log_streaming": {
-                        const validatedArgs = StartLogStreamingArgsSchema.parse(args);
-                        const command = validatedArgs.command || "npm run dev";
-                        const cwd = resolve(validatedArgs.cwd || process.cwd());
-                        // Determine output file path using structured logging or legacy approach
-                        let outputFile;
-                        if (this.shouldUseStructuredLogging(validatedArgs)) {
-                            outputFile = this.createStructuredLogPath(command, validatedArgs.sessionDate, validatedArgs.logType);
-                            // Clean up old logs when using structured logging (keeps last 3 days)
-                            this.cleanupOldLogs(3);
-                        }
-                        else {
-                            outputFile = resolve(validatedArgs.outputFile || "dev-server-logs.txt");
-                        }
-                        // Generate or use provided process ID
-                        let processId = validatedArgs.processId || this.generateProcessId(command, outputFile);
-                        // Ensure unique process ID
-                        let counter = 1;
-                        const originalProcessId = processId;
-                        while (this.activeServers.has(processId)) {
-                            processId = `${originalProcessId}-${counter}`;
-                            counter++;
-                        }
-                        // Parse command into program and args
-                        const [program, ...cmdArgs] = command.split(' ');
-                        // Create or clear the output file
-                        writeFileSync(outputFile, `[${new Date().toISOString()}] Starting: ${command} (Process ID: ${processId})\n`);
-                        try {
-                            // Spawn the process (detached to avoid signal propagation)
-                            const devProcess = spawn(program, cmdArgs, {
-                                cwd: cwd,
-                                env: { ...process.env, ...validatedArgs.env },
-                                detached: true,
-                                stdio: ['ignore', 'pipe', 'pipe']
-                            });
-                            const serverInfo = {
-                                process: devProcess,
-                                command: command,
-                                cwd: cwd,
-                                outputFile: outputFile,
-                                startTime: new Date(),
-                                pid: devProcess.pid,
-                                processId: processId
-                            };
-                            this.activeServers.set(processId, serverInfo);
-                            // Stream stdout to file
-                            devProcess.stdout?.on('data', (data) => {
-                                const timestamp = new Date().toISOString();
-                                const logEntry = `[${timestamp}] [${processId}] ${data}`;
-                                appendFileSync(outputFile, logEntry);
-                            });
-                            // Stream stderr to file
-                            devProcess.stderr?.on('data', (data) => {
-                                const timestamp = new Date().toISOString();
-                                const logEntry = `[${timestamp}] [${processId}] [ERROR] ${data}`;
-                                appendFileSync(outputFile, logEntry);
-                            });
-                            // Handle process exit
-                            devProcess.on('exit', (code, signal) => {
-                                const timestamp = new Date().toISOString();
-                                const exitMessage = `[${timestamp}] [${processId}] Process exited with code ${code} and signal ${signal}\n`;
-                                appendFileSync(outputFile, exitMessage);
-                                this.activeServers.delete(processId);
-                                this.saveState();
-                            });
-                            // Handle process errors
-                            devProcess.on('error', (error) => {
-                                const timestamp = new Date().toISOString();
-                                const errorMessage = `[${timestamp}] [${processId}] Process error: ${error.message}\n`;
-                                appendFileSync(outputFile, errorMessage);
-                            });
-                            this.saveState();
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            status: "started",
-                                            processId: processId,
-                                            pid: devProcess.pid,
-                                            command: command,
-                                            cwd: cwd,
-                                            outputFile: outputFile,
-                                            message: `Dev server started with process ID: ${processId}. Logs streaming to ${outputFile}`
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                        catch (error) {
-                            throw new Error(`Failed to start dev server: ${error instanceof Error ? error.message : String(error)}`);
-                        }
-                    }
-                    case "dev_get_processes": {
-                        const validatedArgs = GetProcessesArgsSchema.parse(args);
-                        const format = validatedArgs.format || "formatted";
-                        if (validatedArgs.processId) {
-                            // Get info for specific process
-                            const serverInfo = this.activeServers.get(validatedArgs.processId);
-                            if (!serverInfo) {
-                                return {
-                                    content: [
-                                        {
-                                            type: "text",
-                                            text: JSON.stringify({
-                                                status: "not_found",
-                                                message: `Process with ID '${validatedArgs.processId}' not found`
-                                            }, null, 2)
-                                        }
-                                    ]
-                                };
-                            }
-                            const uptime = new Date().getTime() - serverInfo.startTime.getTime();
-                            const processInfo = {
-                                processId: serverInfo.processId,
-                                pid: serverInfo.pid,
-                                command: serverInfo.command,
-                                cwd: serverInfo.cwd,
-                                outputFile: serverInfo.outputFile,
-                                startTime: serverInfo.startTime,
-                                uptime: format === "raw" ? uptime : {
-                                    hours: Math.floor(uptime / 3600000),
-                                    minutes: Math.floor((uptime % 3600000) / 60000),
-                                    seconds: Math.floor((uptime % 60000) / 1000)
-                                }
-                            };
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            status: "running",
-                                            process: processInfo
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                        else {
-                            // Get info for all processes
-                            if (this.activeServers.size === 0) {
-                                return {
-                                    content: [
-                                        {
-                                            type: "text",
-                                            text: JSON.stringify({
-                                                status: "not_running",
-                                                message: "No dev servers are currently running"
-                                            }, null, 2)
-                                        }
-                                    ]
-                                };
-                            }
-                            const processes = Array.from(this.activeServers.values()).map(serverInfo => {
-                                const uptime = new Date().getTime() - serverInfo.startTime.getTime();
-                                return {
-                                    processId: serverInfo.processId,
-                                    pid: serverInfo.pid,
-                                    command: serverInfo.command,
-                                    cwd: serverInfo.cwd,
-                                    outputFile: serverInfo.outputFile,
-                                    startTime: serverInfo.startTime,
-                                    uptime: format === "raw" ? uptime : {
-                                        hours: Math.floor(uptime / 3600000),
-                                        minutes: Math.floor((uptime % 3600000) / 60000),
-                                        seconds: Math.floor((uptime % 60000) / 1000)
-                                    }
-                                };
-                            });
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            status: "running",
-                                            totalProcesses: processes.length,
-                                            processes: processes
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                    }
-                    case "dev_stop_log_streaming": {
-                        const validatedArgs = StopLogStreamingArgsSchema.parse(args);
-                        if (validatedArgs.processId) {
-                            // Stop specific process
-                            const serverInfo = this.activeServers.get(validatedArgs.processId);
-                            if (!serverInfo) {
-                                return {
-                                    content: [
-                                        {
-                                            type: "text",
-                                            text: JSON.stringify({
-                                                status: "not_found",
-                                                message: `Process with ID '${validatedArgs.processId}' not found`
-                                            }, null, 2)
-                                        }
-                                    ]
-                                };
-                            }
-                            try {
-                                // Close browser if running
-                                if (serverInfo.browser) {
-                                    await serverInfo.browser.close();
-                                }
-                                // Remove all event listeners to prevent memory leaks
-                                if (serverInfo.process) {
-                                    serverInfo.process.stdout?.removeAllListeners('data');
-                                    serverInfo.process.stderr?.removeAllListeners('data');
-                                    serverInfo.process.removeAllListeners('exit');
-                                    serverInfo.process.removeAllListeners('error');
-                                }
-                                if (serverInfo.pid) {
-                                    process.kill(serverInfo.pid, 'SIGTERM');
-                                }
-                                this.activeServers.delete(validatedArgs.processId);
-                                this.saveState();
-                                return {
-                                    content: [
-                                        {
-                                            type: "text",
-                                            text: JSON.stringify({
-                                                status: "stopped",
-                                                processId: validatedArgs.processId,
-                                                message: `Process '${validatedArgs.processId}' stopped successfully`
-                                            }, null, 2)
-                                        }
-                                    ]
-                                };
-                            }
-                            catch (error) {
-                                throw new Error(`Failed to stop process '${validatedArgs.processId}': ${error instanceof Error ? error.message : String(error)}`);
-                            }
-                        }
-                        else {
-                            // Stop all processes
-                            if (this.activeServers.size === 0) {
-                                return {
-                                    content: [
-                                        {
-                                            type: "text",
-                                            text: JSON.stringify({
-                                                status: "not_running",
-                                                message: "No dev servers are currently running"
-                                            }, null, 2)
-                                        }
-                                    ]
-                                };
-                            }
-                            const stoppedProcesses = [];
-                            for (const [processId, serverInfo] of this.activeServers) {
-                                try {
-                                    // Close browser if running
-                                    if (serverInfo.browser) {
-                                        await serverInfo.browser.close();
-                                    }
-                                    // Remove all event listeners to prevent memory leaks
-                                    if (serverInfo.process) {
-                                        serverInfo.process.stdout?.removeAllListeners('data');
-                                        serverInfo.process.stderr?.removeAllListeners('data');
-                                        serverInfo.process.removeAllListeners('exit');
-                                        serverInfo.process.removeAllListeners('error');
-                                    }
-                                    if (serverInfo.pid) {
-                                        process.kill(serverInfo.pid, 'SIGTERM');
-                                    }
-                                    stoppedProcesses.push(processId);
-                                }
-                                catch (error) {
-                                    // Continue with other processes even if one fails
-                                }
-                            }
-                            this.activeServers.clear();
-                            this.saveState();
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            status: "stopped",
-                                            stoppedProcesses: stoppedProcesses,
-                                            message: `Stopped ${stoppedProcesses.length} processes`
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                    }
-                    case "dev_restart_log_streaming": {
-                        const validatedArgs = RestartLogStreamingArgsSchema.parse(args);
-                        const processId = validatedArgs.processId;
-                        const serverInfo = this.activeServers.get(processId);
-                        if (!serverInfo) {
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            status: "not_found",
-                                            message: `Process with ID '${processId}' not found. Use dev_list_processes to see available processes.`
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                        // Save current configuration
-                        const { command, cwd, outputFile } = serverInfo;
-                        // Stop current process
-                        try {
-                            // Remove all event listeners to prevent memory leaks
-                            if (serverInfo.process) {
-                                serverInfo.process.stdout?.removeAllListeners('data');
-                                serverInfo.process.stderr?.removeAllListeners('data');
-                                serverInfo.process.removeAllListeners('exit');
-                                serverInfo.process.removeAllListeners('error');
-                            }
-                            if (serverInfo.pid) {
-                                process.kill(serverInfo.pid, 'SIGTERM');
-                            }
-                        }
-                        catch (error) {
-                            // Process might already be dead
-                        }
-                        // Clear logs if requested
-                        if (validatedArgs.clearLogs && existsSync(outputFile)) {
-                            writeFileSync(outputFile, '');
-                        }
-                        // Remove the old server info to ensure complete cleanup
-                        this.activeServers.delete(processId);
-                        // Wait a moment for process to die
-                        await new Promise(resolve => setTimeout(resolve, 1000));
-                        // Start new process
-                        const [program, ...cmdArgs] = command.split(' ');
-                        const restartMessage = `[${new Date().toISOString()}] Restarting: ${command} (Process ID: ${processId})\n`;
-                        if (validatedArgs.clearLogs) {
-                            writeFileSync(outputFile, restartMessage);
-                        }
-                        else {
-                            appendFileSync(outputFile, restartMessage);
-                        }
-                        const devProcess = spawn(program, cmdArgs, {
-                            cwd: cwd,
-                            env: process.env,
-                            detached: true,
-                            stdio: ['ignore', 'pipe', 'pipe']
-                        });
-                        const newServerInfo = {
-                            process: devProcess,
-                            command: command,
-                            cwd: cwd,
-                            outputFile: outputFile,
-                            startTime: new Date(),
-                            pid: devProcess.pid,
-                            processId: processId
-                        };
-                        this.activeServers.set(processId, newServerInfo);
-                        // Stream stdout to file
-                        devProcess.stdout?.on('data', (data) => {
-                            const timestamp = new Date().toISOString();
-                            const logEntry = `[${timestamp}] [${processId}] ${data}`;
-                            appendFileSync(outputFile, logEntry);
-                        });
-                        // Stream stderr to file
-                        devProcess.stderr?.on('data', (data) => {
-                            const timestamp = new Date().toISOString();
-                            const logEntry = `[${timestamp}] [${processId}] [ERROR] ${data}`;
-                            appendFileSync(outputFile, logEntry);
-                        });
-                        // Handle process exit
-                        devProcess.on('exit', (code, signal) => {
-                            const timestamp = new Date().toISOString();
-                            const exitMessage = `[${timestamp}] [${processId}] Process exited with code ${code} and signal ${signal}\n`;
-                            appendFileSync(outputFile, exitMessage);
-                            this.activeServers.delete(processId);
-                            this.saveState();
-                        });
-                        // Handle process errors
-                        devProcess.on('error', (error) => {
-                            const timestamp = new Date().toISOString();
-                            const errorMessage = `[${timestamp}] [${processId}] Process error: ${error.message}\n`;
-                            appendFileSync(outputFile, errorMessage);
-                        });
-                        this.saveState();
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: JSON.stringify({
-                                        status: "restarted",
-                                        processId: processId,
-                                        pid: devProcess.pid,
-                                        command: command,
-                                        outputFile: outputFile,
-                                        message: `Process '${processId}' restarted successfully`
-                                    }, null, 2)
-                                }
-                            ]
-                        };
-                    }
-                    case "dev_tail_logs": {
-                        const validatedArgs = TailLogsArgsSchema.parse(args);
-                        // Find the process or use the default behavior
-                        const processId = this.findProcessOrDefault(validatedArgs.processId);
-                        if (!processId && validatedArgs.processId) {
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            status: "not_found",
-                                            message: `Process with ID '${validatedArgs.processId}' not found`
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                        if (!processId && this.activeServers.size > 1) {
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            status: "ambiguous",
-                                            message: "Multiple processes running. Please specify processId or use dev_list_processes to see options.",
-                                            availableProcesses: Array.from(this.activeServers.keys())
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                        // Get the output file
-                        let outputFile;
-                        if (processId) {
-                            const serverInfo = this.activeServers.get(processId);
-                            outputFile = serverInfo.outputFile;
-                        }
-                        else {
-                            outputFile = "dev-server-logs.txt"; // fallback
-                        }
-                        if (!existsSync(outputFile)) {
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            status: "error",
-                                            message: `Log file not found: ${outputFile}`
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                        try {
-                            // Read the file
-                            const content = readFileSync(outputFile, 'utf8');
-                            const lines = content.split('\n').filter(line => line.trim());
-                            // Filter if pattern provided
-                            let filteredLines = lines;
-                            if (validatedArgs.filter) {
-                                const pattern = new RegExp(validatedArgs.filter, 'i');
-                                filteredLines = lines.filter(line => pattern.test(line));
-                            }
-                            // Get last N lines
-                            const numLines = validatedArgs.lines || 50;
-                            const lastLines = filteredLines.slice(-numLines);
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            status: "success",
-                                            processId: processId || "default",
-                                            file: outputFile,
-                                            totalLines: lines.length,
-                                            filteredLines: filteredLines.length,
-                                            returnedLines: lastLines.length,
-                                            logs: lastLines
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                        catch (error) {
-                            throw new Error(`Failed to read logs: ${error instanceof Error ? error.message : String(error)}`);
-                        }
-                    }
-                    case "dev_clear_logs": {
-                        const validatedArgs = ClearLogsArgsSchema.parse(args);
-                        // Find the process or use the default behavior
-                        const processId = this.findProcessOrDefault(validatedArgs.processId);
-                        if (!processId && validatedArgs.processId) {
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            status: "not_found",
-                                            message: `Process with ID '${validatedArgs.processId}' not found`
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                        if (!processId && this.activeServers.size > 1) {
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            status: "ambiguous",
-                                            message: "Multiple processes running. Please specify processId or use dev_list_processes to see options.",
-                                            availableProcesses: Array.from(this.activeServers.keys())
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                        // Get the output file
-                        let outputFile;
-                        if (processId) {
-                            const serverInfo = this.activeServers.get(processId);
-                            outputFile = serverInfo.outputFile;
-                        }
-                        else {
-                            outputFile = "dev-server-logs.txt"; // fallback
-                        }
-                        if (!existsSync(outputFile)) {
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            status: "error",
-                                            message: `Log file not found: ${outputFile}`
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                        try {
-                            // Backup if requested
-                            if (validatedArgs.backup) {
-                                const backupFile = `${outputFile}.${new Date().getTime()}.backup`;
-                                copyFileSync(outputFile, backupFile);
-                            }
-                            // Clear the file
-                            writeFileSync(outputFile, '');
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            status: "success",
-                                            processId: processId || "default",
-                                            message: `Log file cleared: ${outputFile}`,
-                                            backup: validatedArgs.backup ? "Created backup" : "No backup created"
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                        catch (error) {
-                            throw new Error(`Failed to clear logs: ${error instanceof Error ? error.message : String(error)}`);
-                        }
-                    }
-                    case "dev_check_running_processes": {
-                        const validatedArgs = CheckRunningProcessesArgsSchema.parse(args);
-                        try {
-                            const result = await this.checkRunningProcesses(validatedArgs.processType, validatedArgs.port);
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify(result, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                        catch (error) {
-                            throw new Error(`Failed to check running processes: ${error instanceof Error ? error.message : String(error)}`);
-                        }
-                    }
-                    case "dev_discover_logs": {
-                        const validatedArgs = DiscoverLogsArgsSchema.parse(args);
-                        try {
-                            const result = await this.discoverLogs(validatedArgs.sessionDate);
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify(result, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                        catch (error) {
-                            throw new Error(`Failed to discover logs: ${error instanceof Error ? error.message : String(error)}`);
-                        }
-                    }
-                    case "dev_launch_test_browser": {
-                        const validatedArgs = z.object({
-                            processId: z.string().optional(),
-                            browserUrl: z.string().optional(),
-                            teachingMode: z.boolean().optional(),
-                            viewport: z.object({
-                                width: z.number().default(1920),
-                                height: z.number().default(1080)
-                            }).optional(),
-                            highlightErrors: z.boolean().optional()
-                        }).parse(args);
-                        try {
-                            // Find the process to attach to
-                            const processId = this.findProcessOrDefault(validatedArgs.processId);
-                            if (!processId) {
-                                return {
-                                    content: [
-                                        {
-                                            type: "text",
-                                            text: JSON.stringify({
-                                                status: "error",
-                                                message: "No dev server process found. Start a dev server first with dev_start_log_streaming"
-                                            }, null, 2)
-                                        }
-                                    ]
-                                };
-                            }
-                            const serverInfo = this.activeServers.get(processId);
-                            // Check if browser already running for this process
-                            if (serverInfo.browser) {
-                                return {
-                                    content: [
-                                        {
-                                            type: "text",
-                                            text: JSON.stringify({
-                                                status: "already_running",
-                                                message: `Browser console capture already active for process '${processId}'`
-                                            }, null, 2)
-                                        }
-                                    ]
-                                };
-                            }
-                            // Launch browser with student-friendly defaults
-                            const teachingMode = validatedArgs.teachingMode !== false;
-                            const viewport = validatedArgs.viewport || { width: 1920, height: 1080 };
-                            const browser = await chromium.launch({
-                                headless: false, // Always visible for students
-                                slowMo: teachingMode ? 50 : 0, // Slow down actions in teaching mode
-                                devtools: teachingMode, // Open DevTools in teaching mode
-                                args: [
-                                    `--window-size=${viewport.width},${viewport.height}`,
-                                    '--window-position=100,100',
-                                    '--disable-features=RendererCodeIntegrity' // Prevent some security warnings
-                                ]
-                            });
-                            const context = await browser.newContext({
-                                viewport: viewport,
-                                ignoreHTTPSErrors: true // Common in dev environments
-                            });
-                            const page = await context.newPage();
-                            // Add page title to identify this as the test browser
-                            await page.evaluate(() => {
-                                // @ts-ignore - browser context
-                                document.title = '🧪 TEST BROWSER - Console Logs Captured';
-                            });
-                            // Set up console event handler with student-friendly features
-                            const highlightErrors = validatedArgs.highlightErrors !== false;
-                            page.on('console', (msg) => {
-                                const msgType = msg.type();
-                                const timestamp = new Date().toISOString();
-                                const args = msg.args();
-                                // Format console message
-                                let messageText = msg.text();
-                                // Visual feedback for errors in teaching mode
-                                if (highlightErrors && msgType === 'error') {
-                                    page.evaluate(() => {
-                                        // @ts-ignore - browser context
-                                        const flash = document.createElement('div');
-                                        flash.style.cssText = `
-                      position: fixed;
-                      top: 0;
-                      left: 0;
-                      right: 0;
-                      bottom: 0;
-                      border: 5px solid red;
-                      pointer-events: none;
-                      z-index: 999999;
-                      animation: flash 0.5s ease-in-out;
-                    `;
-                                        flash.innerHTML = `
-                      <div style="
-                        background: red;
-                        color: white;
-                        padding: 10px;
-                        position: absolute;
-                        top: 0;
-                        left: 0;
-                        right: 0;
-                        text-align: center;
-                        font-family: monospace;
-                      ">⚠️ Console Error Detected - Check Logs!</div>
-                    `;
-                                        // @ts-ignore - browser context
-                                        document.body.appendChild(flash);
-                                        setTimeout(() => flash.remove(), 2000);
-                                    }).catch(() => { });
-                                }
-                                // Try to get better formatting for objects
-                                if (args.length > 0) {
-                                    Promise.all(args.map(arg => arg.jsonValue().catch(() => arg.toString())))
-                                        .then(values => {
-                                        const formattedMsg = values.map(v => typeof v === 'object' ? JSON.stringify(v, null, 2) : String(v)).join(' ');
-                                        const logEntry = `[${timestamp}] [${processId}] [BROWSER] [${msgType.toUpperCase()}] ${formattedMsg}\n`;
-                                        appendFileSync(serverInfo.outputFile, logEntry);
-                                        // Also log to terminal for immediate feedback
-                                        if (msgType === 'error' || msgType === 'warning') {
-                                            console.error(`[STUDENT BROWSER] ${msgType === 'warning' ? 'WARN' : msgType.toUpperCase()}: ${formattedMsg}`);
-                                        }
-                                    })
-                                        .catch(() => {
-                                        // Fallback to simple text
-                                        const logEntry = `[${timestamp}] [${processId}] [BROWSER] [${msgType.toUpperCase()}] ${messageText}\n`;
-                                        appendFileSync(serverInfo.outputFile, logEntry);
-                                    });
-                                }
-                                else {
-                                    const logEntry = `[${timestamp}] [${processId}] [BROWSER] [${msgType.toUpperCase()}] ${messageText}\n`;
-                                    appendFileSync(serverInfo.outputFile, logEntry);
-                                }
-                            });
-                            // Handle page errors (including hydration errors)
-                            page.on('pageerror', (error) => {
-                                const timestamp = new Date().toISOString();
-                                const logEntry = `[${timestamp}] [${processId}] [BROWSER] [PAGE ERROR] ${error.message}\n${error.stack}\n`;
-                                appendFileSync(serverInfo.outputFile, logEntry);
-                                // Visual feedback for page errors
-                                page.evaluate(() => {
-                                    // @ts-ignore - browser context
-                                    const errorBanner = document.createElement('div');
-                                    errorBanner.style.cssText = `
-                    position: fixed;
-                    top: 40px;
-                    left: 50%;
-                    transform: translateX(-50%);
-                    background: #dc2626;
-                    color: white;
-                    padding: 12px 24px;
-                    border-radius: 6px;
-                    font-family: monospace;
-                    font-size: 14px;
-                    z-index: 999999;
-                    box-shadow: 0 4px 6px rgba(0,0,0,0.3);
-                    animation: slideDown 0.3s ease-out;
-                  `;
-                                    errorBanner.textContent = '⚠️ JavaScript Error - Check Console & Logs';
-                                    // @ts-ignore - browser context
-                                    const style = document.createElement('style');
-                                    style.textContent = `
-                    @keyframes slideDown {
-                      from { transform: translate(-50%, -100%); opacity: 0; }
-                      to { transform: translate(-50%, 0); opacity: 1; }
-                    }
-                  `;
-                                    // @ts-ignore - browser context
-                                    document.head.appendChild(style);
-                                    // @ts-ignore - browser context
-                                    document.body.appendChild(errorBanner);
-                                    setTimeout(() => errorBanner.remove(), 5000);
-                                }).catch(() => { });
-                            });
-                            // Handle unhandled promise rejections
-                            await page.addInitScript(() => {
-                                // @ts-ignore - browser context
-                                window.addEventListener('unhandledrejection', (event) => {
-                                    console.error('Unhandled Promise Rejection:', event.reason);
-                                });
-                            });
-                            // Handle network response errors
-                            page.on('response', (response) => {
-                                if (response.status() >= 400) {
-                                    const timestamp = new Date().toISOString();
-                                    const logEntry = `[${timestamp}] [${processId}] [BROWSER] [NETWORK ERROR] ${response.status()} ${response.statusText()} - ${response.url()}\n`;
-                                    appendFileSync(serverInfo.outputFile, logEntry);
-                                }
-                            });
-                            // Navigate to URL
-                            const browserUrl = validatedArgs.browserUrl || "http://localhost:3000";
-                            try {
-                                await page.goto(browserUrl, { waitUntil: 'domcontentloaded' });
-                                // Add student instruction banner (hydration-safe version)
-                                if (teachingMode) {
-                                    // @ts-ignore
-                                    await page.evaluate(() => {
-                                        function injectTestBanner() {
-                                            // Create a container that won't interfere with React hydration
-                                            const container = document.createElement('div');
-                                            container.id = 'test-browser-banner-container';
-                                            container.style.cssText = 'position: fixed; top: 0; left: 0; width: 100%; z-index: 2147483647; pointer-events: none;';
-                                            // Use shadow DOM to isolate the banner completely
-                                            const shadow = container.attachShadow({ mode: 'open' });
-                                            // Create banner in shadow DOM
-                                            const banner = document.createElement('div');
-                                            banner.style.cssText = `
-                        position: fixed;
-                        top: 0;
-                        left: 0;
-                        right: 0;
-                        background: #4CAF50;
-                        color: white;
-                        padding: 10px;
-                        text-align: center;
-                        font-family: monospace;
-                        font-size: 14px;
-                        box-shadow: 0 2px 5px rgba(0,0,0,0.2);
-                        pointer-events: auto;
-                      `;
-                                            banner.innerHTML = `
-                        🧪 TEST BROWSER - All console logs are being captured! 
-                        <button style="
-                          margin-left: 20px;
-                          background: transparent;
-                          border: 1px solid white;
-                          color: white;
-                          padding: 2px 10px;
-                          cursor: pointer;
-                        ">Hide</button>
-                      `;
-                                            // Add click handler to hide button
-                                            const button = banner.querySelector('button');
-                                            if (button) {
-                                                button.addEventListener('click', () => {
-                                                    container.style.display = 'none';
-                                                });
-                                            }
-                                            shadow.appendChild(banner);
-                                            document.documentElement.appendChild(container);
-                                        }
-                                        // Wait for hydration to complete before injecting
-                                        if (typeof window !== 'undefined') {
-                                            // Check for Next.js hydration
-                                            if (window.__NEXT_HYDRATED) {
-                                                injectTestBanner();
-                                            }
-                                            else {
-                                                // Wait for React to finish hydrating
-                                                let attempts = 0;
-                                                const checkHydration = setInterval(() => {
-                                                    attempts++;
-                                                    // Check various hydration indicators
-                                                    if (window.__NEXT_HYDRATED || window._react_root || document.querySelector('[data-reactroot]') || attempts > 20) {
-                                                        clearInterval(checkHydration);
-                                                        // Add a small delay to be extra safe
-                                                        setTimeout(injectTestBanner, 100);
-                                                    }
-                                                }, 250);
-                                            }
-                                        }
-                                    }).catch(() => { });
-                                }
-                            }
-                            catch (error) {
-                                const timestamp = new Date().toISOString();
-                                const logEntry = `[${timestamp}] [${processId}] [BROWSER] [NAVIGATION ERROR] Failed to navigate to ${browserUrl}: ${error}\n`;
-                                appendFileSync(serverInfo.outputFile, logEntry);
-                            }
-                            // Update server info
-                            serverInfo.browser = browser;
-                            serverInfo.page = page;
-                            serverInfo.browserUrl = browserUrl;
-                            serverInfo.consoleCapture = true;
-                            // Log browser start
-                            const timestamp = new Date().toISOString();
-                            const logEntry = `[${timestamp}] [${processId}] [BROWSER] Console capture started for ${browserUrl}\n`;
-                            appendFileSync(serverInfo.outputFile, logEntry);
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            status: "started",
-                                            processId: processId,
-                                            browserUrl: browserUrl,
-                                            teachingMode: teachingMode,
-                                            message: `🧪 TEST BROWSER LAUNCHED!\n\n` +
-                                                `👉 IMPORTANT: Students should use THIS browser window (not their regular browser)\n` +
-                                                `📝 All console logs are being captured to: ${serverInfo.outputFile}\n` +
-                                                `🔍 DevTools is ${teachingMode ? 'OPEN' : 'CLOSED'} for debugging\n` +
-                                                `⚠️  Errors will ${highlightErrors ? 'flash red' : 'not flash'} on screen\n\n` +
-                                                `Students can now interact with the app at: ${browserUrl}`
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                        catch (error) {
-                            throw new Error(`Failed to start browser console capture: ${error instanceof Error ? error.message : String(error)}`);
-                        }
-                    }
-                    case "dev_stop_browser_console": {
-                        const validatedArgs = z.object({
-                            processId: z.string().optional()
-                        }).parse(args);
-                        try {
-                            const processId = this.findProcessOrDefault(validatedArgs.processId);
-                            if (!processId) {
-                                return {
-                                    content: [
-                                        {
-                                            type: "text",
-                                            text: JSON.stringify({
-                                                status: "error",
-                                                message: "No process found"
-                                            }, null, 2)
-                                        }
-                                    ]
-                                };
-                            }
-                            const serverInfo = this.activeServers.get(processId);
-                            if (!serverInfo || !serverInfo.browser) {
-                                return {
-                                    content: [
-                                        {
-                                            type: "text",
-                                            text: JSON.stringify({
-                                                status: "not_running",
-                                                message: `No browser console capture running for process '${processId}'`
-                                            }, null, 2)
-                                        }
-                                    ]
-                                };
-                            }
-                            // Close browser
-                            await serverInfo.browser.close();
-                            // Clear browser info
-                            serverInfo.browser = undefined;
-                            serverInfo.page = undefined;
-                            serverInfo.browserUrl = undefined;
-                            serverInfo.consoleCapture = false;
-                            // Log browser stop
-                            const timestamp = new Date().toISOString();
-                            const logEntry = `[${timestamp}] [${processId}] [BROWSER] Console capture stopped\n`;
-                            appendFileSync(serverInfo.outputFile, logEntry);
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            status: "stopped",
-                                            processId: processId,
-                                            message: `Browser console capture stopped for process '${processId}'`
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
-                        }
-                        catch (error) {
-                            throw new Error(`Failed to stop browser console capture: ${error instanceof Error ? error.message : String(error)}`);
-                        }
-                    }
-                    case "dev_start_frontend_with_browser": {
-                        const validatedArgs = StartFrontendWithBrowserArgsSchema.parse(args);
-                        // Defaults
-                        const command = validatedArgs.command || "npm run dev";
-                        const processId = validatedArgs.processId || "frontend-with-browser";
-                        const cwd = resolve(validatedArgs.cwd || process.cwd());
-                        const waitTimeout = validatedArgs.waitTimeout || 30000;
-                        const browserDelay = validatedArgs.browserDelay || 1000;
-                        const teachingMode = validatedArgs.teachingMode !== false; // default true
-                        try {
-                            // Check if process already exists
-                            if (this.activeServers.has(processId)) {
-                                throw new Error(`Process '${processId}' is already running. Stop it first or use a different processId.`);
-                            }
-                            // Step 1: Start the dev server
-                            const outputFile = this.createStructuredLogPath(command, undefined, "frontend");
-                            this.cleanupOldLogs(3);
-                            const [program, ...cmdArgs] = command.split(' ');
-                            // Initial log entry
-                            writeFileSync(outputFile, `[${new Date().toISOString()}] Starting: ${command} (Process ID: ${processId})\n`);
-                            appendFileSync(outputFile, `[${new Date().toISOString()}] [${processId}] ✅ Starting development server...\n`);
-                            // Spawn the process
-                            const devProcess = spawn(program, cmdArgs, {
-                                cwd: cwd,
-                                env: { ...process.env, ...validatedArgs.env },
-                                detached: true,
-                                stdio: ['ignore', 'pipe', 'pipe']
-                            });
-                            const serverInfo = {
-                                process: devProcess,
-                                command: command,
-                                cwd: cwd,
-                                outputFile: outputFile,
-                                startTime: new Date(),
-                                pid: devProcess.pid,
-                                processId: processId
-                            };
-                            this.activeServers.set(processId, serverInfo);
-                            // Variables for port detection
-                            let detectedPort = validatedArgs.port || null;
-                            let serverReady = false;
-                            let outputBuffer = "";
-                            // Common port patterns
-                            const portPatterns = [
-                                /(?:Local|Listening|ready).*?(\d{4})/i,
-                                /localhost:(\d{4})/,
-                                /port\s*:?\s*(\d{4})/i,
-                                /on\s+http:\/\/localhost:(\d{4})/i,
-                                /Server running at.*?:(\d{4})/i
-                            ];
-                            // Ready indicators
-                            const readyPatterns = [
-                                /Local:\s*http:\/\/localhost/i,
-                                /ready on http:\/\/localhost/i,
-                                /Server running at/i,
-                                /Listening on port/i,
-                                /started server on/i,
-                                /Ready in \d+ms/i,
-                                /compiled successfully/i
-                            ];
-                            // Create promise for server ready detection
-                            const serverReadyPromise = new Promise((resolve, reject) => {
-                                const timeout = setTimeout(() => {
-                                    reject(new Error(`Server did not start within ${waitTimeout}ms`));
-                                }, waitTimeout);
-                                const checkOutput = (data) => {
-                                    const text = data.toString();
-                                    outputBuffer += text;
-                                    // Check for port if not detected
-                                    if (!detectedPort) {
-                                        for (const pattern of portPatterns) {
-                                            const match = outputBuffer.match(pattern);
-                                            if (match && match[1]) {
-                                                detectedPort = parseInt(match[1]);
-                                                appendFileSync(outputFile, `[${new Date().toISOString()}] [${processId}] 🔍 Detected port: ${detectedPort}\n`);
-                                                break;
-                                            }
-                                        }
-                                    }
-                                    // Check for ready state
-                                    if (!serverReady) {
-                                        for (const pattern of readyPatterns) {
-                                            if (pattern.test(outputBuffer)) {
-                                                serverReady = true;
-                                                clearTimeout(timeout);
-                                                // If we have a port, resolve immediately
-                                                if (detectedPort) {
-                                                    resolve(detectedPort);
-                                                }
-                                                else {
-                                                    // Try common ports
-                                                    const commonPorts = [3000, 3001, 5173, 8080, 4200];
-                                                    detectedPort = commonPorts[0]; // Default to 3000
-                                                    appendFileSync(outputFile, `[${new Date().toISOString()}] [${processId}] ⚠️  Could not detect port, defaulting to ${detectedPort}\n`);
-                                                    resolve(detectedPort);
-                                                }
-                                                break;
-                                            }
-                                        }
-                                    }
-                                };
-                                // Attach listeners
-                                devProcess.stdout?.on('data', checkOutput);
-                                devProcess.stderr?.on('data', checkOutput);
-                            });
-                            // Stream stdout to file
-                            devProcess.stdout?.on('data', (data) => {
-                                const timestamp = new Date().toISOString();
-                                const logEntry = `[${timestamp}] [${processId}] ${data}`;
-                                appendFileSync(outputFile, logEntry);
-                            });
-                            // Stream stderr to file
-                            devProcess.stderr?.on('data', (data) => {
-                                const timestamp = new Date().toISOString();
-                                const logEntry = `[${timestamp}] [${processId}] [ERROR] ${data}`;
-                                appendFileSync(outputFile, logEntry);
-                            });
-                            // Handle process exit
-                            devProcess.on('exit', (code, signal) => {
-                                const timestamp = new Date().toISOString();
-                                const exitMessage = `[${timestamp}] [${processId}] Process exited with code ${code} and signal ${signal}\n`;
-                                appendFileSync(outputFile, exitMessage);
-                                this.activeServers.delete(processId);
-                                this.saveState();
-                            });
-                            // Handle process errors
-                            devProcess.on('error', (error) => {
-                                const timestamp = new Date().toISOString();
-                                const errorMessage = `[${timestamp}] [${processId}] Process error: ${error.message}\n`;
-                                appendFileSync(outputFile, errorMessage);
-                            });
-                            this.saveState();
-                            // Step 2: Wait for server to be ready
-                            let port;
-                            try {
-                                port = await serverReadyPromise;
-                                appendFileSync(outputFile, `[${new Date().toISOString()}] [${processId}] ✅ Server ready on http://localhost:${port}\n`);
-                            }
-                            catch (error) {
-                                // Server didn't start properly, clean up
-                                const failedServerInfo = this.activeServers.get(processId);
-                                if (failedServerInfo) {
-                                    try {
-                                        // Close browser if it exists
-                                        if (failedServerInfo.browser) {
-                                            await failedServerInfo.browser.close();
-                                        }
-                                        // Remove all event listeners to prevent memory leaks
-                                        if (failedServerInfo.process) {
-                                            failedServerInfo.process.stdout?.removeAllListeners('data');
-                                            failedServerInfo.process.stderr?.removeAllListeners('data');
-                                            failedServerInfo.process.removeAllListeners('exit');
-                                            failedServerInfo.process.removeAllListeners('error');
-                                        }
-                                        // Kill the process
-                                        if (failedServerInfo.pid) {
-                                            process.kill(failedServerInfo.pid, 'SIGTERM');
-                                        }
-                                    }
-                                    catch (killError) {
-                                        // Ignore errors during cleanup
-                                    }
-                                    this.activeServers.delete(processId);
-                                    this.saveState();
-                                }
-                                throw error;
-                            }
-                            // Step 3: Wait a bit more for stability
-                            appendFileSync(outputFile, `[${new Date().toISOString()}] [${processId}] ⏳ Waiting ${browserDelay}ms before launching browser...\n`);
-                            await new Promise(resolve => setTimeout(resolve, browserDelay));
-                            // Step 4: Launch the test browser
-                            try {
-                                appendFileSync(outputFile, `[${new Date().toISOString()}] [${processId}] ✅ Launching test browser...\n`);
-                                const browser = await chromium.launch({
-                                    headless: false,
-                                    slowMo: teachingMode ? 50 : 0,
-                                    devtools: teachingMode,
-                                    args: ['--window-size=1920,1080', '--window-position=100,100']
-                                });
-                                const context = await browser.newContext({
-                                    viewport: { width: 1920, height: 1080 }
-                                });
-                                const page = await context.newPage();
-                                // Add banner to identify test browser (hydration-safe version)
-                                // @ts-ignore
-                                await page.addInitScript(() => {
-                                    function injectTestBanner() {
-                                        // Create a container that won't interfere with React hydration
-                                        const container = document.createElement('div');
-                                        container.id = 'test-browser-banner-container';
-                                        container.style.cssText = 'position: fixed; top: 0; left: 0; width: 100%; z-index: 2147483647; pointer-events: none;';
-                                        // Use shadow DOM to isolate the banner completely
-                                        const shadow = container.attachShadow({ mode: 'open' });
-                                        // Create banner in shadow DOM
-                                        const banner = document.createElement('div');
-                                        banner.style.cssText = `
-                      position: fixed;
-                      top: 0;
-                      left: 0;
-                      right: 0;
-                      background: #22c55e;
-                      color: white;
-                      padding: 8px;
-                      text-align: center;
-                      font-family: monospace;
-                      font-size: 14px;
-                      box-shadow: 0 2px 4px rgba(0,0,0,0.2);
-                      pointer-events: auto;
-                    `;
-                                        banner.textContent = '🧪 TEST BROWSER - All console logs are being captured 📝';
-                                        shadow.appendChild(banner);
-                                        document.documentElement.appendChild(container);
-                                    }
-                                    // Wait for hydration to complete before injecting
-                                    if (typeof window !== 'undefined') {
-                                        // For Next.js apps, wait for hydration
-                                        const waitForHydration = () => {
-                                            let attempts = 0;
-                                            const checkInterval = setInterval(() => {
-                                                attempts++;
-                                                // Check various hydration indicators
-                                                const hydrated = window.__NEXT_HYDRATED ||
-                                                    window._react_root ||
-                                                    document.querySelector('[data-reactroot]') ||
-                                                    document.querySelector('#__next') ||
-                                                    attempts > 20; // Timeout after 5 seconds
-                                                if (hydrated) {
-                                                    clearInterval(checkInterval);
-                                                    // Add a small delay to be extra safe
-                                                    setTimeout(injectTestBanner, 100);
-                                                }
-                                            }, 250);
-                                        };
-                                        // Start checking after DOMContentLoaded
-                                        if (document.readyState === 'loading') {
-                                            document.addEventListener('DOMContentLoaded', waitForHydration);
-                                        }
-                                        else {
-                                            waitForHydration();
-                                        }
-                                    }
-                                });
-                                // Set up console capture
-                                page.on('console', (msg) => {
-                                    const timestamp = new Date().toISOString();
-                                    const msgType = msg.type().toUpperCase();
-                                    const msgText = msg.text();
-                                    const logEntry = `[${timestamp}] [${processId}] [BROWSER] [${msgType}] ${msgText}\n`;
-                                    appendFileSync(outputFile, logEntry);
-                                    // Flash red on errors
-                                    if (msgType === 'ERROR') {
-                                        page.evaluate(() => {
-                                            // @ts-ignore - browser context
-                                            const flash = document.createElement('div');
-                                            flash.style.cssText = `
-                        position: fixed;
-                        top: 0;
-                        left: 0;
-                        right: 0;
-                        bottom: 0;
-                        background: rgba(239, 68, 68, 0.3);
-                        z-index: 999998;
-                        pointer-events: none;
-                        animation: errorFlash 0.5s ease-out;
-                      `;
-                                            // @ts-ignore - browser context
-                                            const style = document.createElement('style');
-                                            style.textContent = `
-                        @keyframes errorFlash {
-                          0% { opacity: 1; }
-                          100% { opacity: 0; }
-                        }
-                      `;
-                                            // @ts-ignore - browser context
-                                            document.head.appendChild(style);
-                                            // @ts-ignore - browser context
-                                            document.body.appendChild(flash);
-                                            setTimeout(() => flash.remove(), 500);
-                                        }).catch(() => { }); // Ignore errors from flashing
-                                    }
-                                });
-                                // Handle page errors (including hydration errors)
-                                page.on('pageerror', (error) => {
-                                    const timestamp = new Date().toISOString();
-                                    const logEntry = `[${timestamp}] [${processId}] [BROWSER] [PAGE ERROR] ${error.message}\n${error.stack}\n`;
-                                    appendFileSync(outputFile, logEntry);
-                                    // Visual feedback for page errors
-                                    page.evaluate(() => {
-                                        // @ts-ignore - browser context
-                                        const errorBanner = document.createElement('div');
-                                        errorBanner.style.cssText = `
-                      position: fixed;
-                      top: 40px;
-                      left: 50%;
-                      transform: translateX(-50%);
-                      background: #dc2626;
-                      color: white;
-                      padding: 12px 24px;
-                      border-radius: 6px;
-                      font-family: monospace;
-                      font-size: 14px;
-                      z-index: 999999;
-                      box-shadow: 0 4px 6px rgba(0,0,0,0.3);
-                      animation: slideDown 0.3s ease-out;
-                    `;
-                                        errorBanner.textContent = '⚠️ JavaScript Error - Check Console & Logs';
-                                        // @ts-ignore - browser context
-                                        const style = document.createElement('style');
-                                        style.textContent = `
-                      @keyframes slideDown {
-                        from { transform: translate(-50%, -100%); opacity: 0; }
-                        to { transform: translate(-50%, 0); opacity: 1; }
-                      }
-                    `;
-                                        // @ts-ignore - browser context
-                                        document.head.appendChild(style);
-                                        // @ts-ignore - browser context
-                                        document.body.appendChild(errorBanner);
-                                        setTimeout(() => errorBanner.remove(), 5000);
-                                    }).catch(() => { });
-                                });
-                                // Handle unhandled promise rejections
-                                await page.addInitScript(() => {
-                                    // @ts-ignore - browser context
-                                    window.addEventListener('unhandledrejection', (event) => {
-                                        console.error('Unhandled Promise Rejection:', event.reason);
-                                    });
-                                });
-                                // Handle network response errors
-                                page.on('response', (response) => {
-                                    if (response.status() >= 400) {
-                                        const timestamp = new Date().toISOString();
-                                        const logEntry = `[${timestamp}] [${processId}] [BROWSER] [NETWORK ERROR] ${response.status()} ${response.statusText()} - ${response.url()}\n`;
-                                        appendFileSync(outputFile, logEntry);
-                                    }
-                                });
-                                // Navigate to the app
-                                const browserUrl = `http://localhost:${port}`;
-                                await page.goto(browserUrl, { waitUntil: 'domcontentloaded' });
-                                // Update server info with browser details
-                                serverInfo.browser = browser;
-                                serverInfo.page = page;
-                                serverInfo.browserUrl = browserUrl;
-                                serverInfo.consoleCapture = true;
-                                // Log success
-                                const successMessage = `
-🎯 TEST BROWSER LAUNCHED!
-
-👉 Use the browser window that just opened (with green banner)
-📝 All console logs are being saved
-🔍 DevTools is open for debugging
-⚠️  Errors will flash red on screen
-
-Happy debugging! 🚀
-`;
-                                appendFileSync(outputFile, `[${new Date().toISOString()}] [${processId}] [BROWSER] Console capture started for ${browserUrl}\n`);
-                                appendFileSync(outputFile, `[${new Date().toISOString()}] [${processId}] ${successMessage}\n`);
-                                return {
-                                    content: [
-                                        {
-                                            type: "text",
-                                            text: JSON.stringify({
-                                                status: "success",
-                                                message: successMessage.trim(),
-                                                processId: processId,
-                                                serverPid: devProcess.pid,
-                                                serverUrl: `http://localhost:${port}`,
-                                                logFile: outputFile,
-                                                browserStatus: "launched",
-                                                teachingMode: teachingMode
-                                            }, null, 2)
-                                        }
-                                    ]
-                                };
-                            }
-                            catch (browserError) {
-                                // Browser launch failed, but server is running
-                                const errorMsg = browserError instanceof Error ? browserError.message : String(browserError);
-                                appendFileSync(outputFile, `[${new Date().toISOString()}] [${processId}] [ERROR] Failed to launch browser: ${errorMsg}\n`);
-                                return {
-                                    content: [
-                                        {
-                                            type: "text",
-                                            text: JSON.stringify({
-                                                status: "partial_success",
-                                                message: `Server started successfully on http://localhost:${port}, but browser launch failed`,
-                                                error: errorMsg,
-                                                processId: processId,
-                                                serverPid: devProcess.pid,
-                                                serverUrl: `http://localhost:${port}`,
-                                                logFile: outputFile,
-                                                browserStatus: "failed",
-                                                manualInstructions: "Open http://localhost:" + port + " in your browser manually"
-                                            }, null, 2)
-                                        }
-                                    ]
-                                };
-                            }
-                        }
-                        catch (error) {
-                            throw new Error(`Failed to start frontend with browser: ${error instanceof Error ? error.message : String(error)}`);
-                        }
-                    }
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
+            case "dev_tail_sandbox_logs": {
+                const validatedArgs = TailSandboxLogsArgsSchema.parse(args);
+                const result = tailSandboxLogs(validatedArgs.lines);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                };
             }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
+            default:
                 return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Error: ${errorMessage}`
-                        }
-                    ],
+                    content: [{ type: "text", text: `Unknown tool: ${name}` }],
                     isError: true
                 };
-            }
-        });
+        }
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        console.error("Dev Logger MCP server running on stdio");
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`
+                }
+            ],
+            isError: true
+        };
+    }
+});
+// Cleanup on exit
+process.on("SIGINT", () => {
+    if (sandboxProcess?.process) {
+        sandboxProcess.process.kill("SIGTERM");
+    }
+    process.exit(0);
+});
+process.on("SIGTERM", () => {
+    if (sandboxProcess?.process) {
+        sandboxProcess.process.kill("SIGTERM");
     }
+    process.exit(0);
+});
+// Start the server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("MCP Dev Logger server running on stdio");
 }
-const server = new DevLoggerServer();
-server.run().catch(console.error);
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});
 //# sourceMappingURL=index.js.map