@ejazullah/browser-mcp 0.0.56

package/index.js

@@ -0,0 +1,1061 @@
+#!/usr/bin/env node
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { createConnection } from './lib/index.js';
+export { createConnection };
+
+
+// main.js (CommonJS) - Router Module
+ const BASE_SYSTEM_PROMPT = `
+You are a STRICT browser automation agent.
+
+You have access ONLY to browser-related tools.
+You do NOT have access to:
+- filesystem tools
+- shell commands
+- terminal access
+- code execution
+- explanations or suggestions outside tools
+
+ABSOLUTE RULES (MANDATORY):
+1. NEVER explain limitations or apologize.
+2. NEVER suggest shell commands, CLI commands, or external solutions.
+3. NEVER say "I cannot do this" without attempting browser actions.
+4. NEVER stop unless the task is fully completed or explicitly impossible via browser.
+
+EXECUTION LOOP (STRICT):
+1. Perform ONE browser tool action.
+2. Immediately take a browser_snapshot.
+3. Analyze ONLY the browser_snapshot.
+4. Decide the next browser action.
+
+If a task is impossible using browser tools:
+- State ONLY: "Task cannot be completed using browser tools."
+- STOP. No explanation. No alternatives.
+
+You MUST follow:
+tool → browser_snapshot → analysis → next action
+
+Breaking these rules is considered FAILURE.
+`
+async function createRouter() {
+    // Import ES modules dynamically
+    const express = await import('express');
+    const {
+        SmartBrowserAutomation,
+        HuggingFaceConfig,
+        OllamaConfig,
+    } = await import('@ejazullah/smart-browser-automation');
+
+    const router = express.default.Router();
+
+    // Store active sessions
+    const activeSessions = new Map();
+
+    // Store running jobs
+    const runningJobs = new Map();
+
+    // Store SSE clients for real-time updates
+    const sseClients = new Map(); // jobId -> Set of response objects
+
+    // Job status enum
+    const JobStatus = {
+        PENDING: 'pending',
+        RUNNING: 'running',
+        COMPLETED: 'completed',
+        FAILED: 'failed',
+        CANCELLED: 'cancelled'
+    };
+
+    // Generate unique job ID
+    function generateJobId() {
+        return `job_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    // SSE utility functions
+    function sendSSEMessage(jobId, type, data) {
+        if (sseClients.has(jobId)) {
+            const clients = sseClients.get(jobId);
+            const message = `data: ${JSON.stringify({ type, data, timestamp: new Date().toISOString() })}\n\n`;
+
+            for (const res of clients) {
+                try {
+                    res.write(message);
+                } catch (error) {
+                    console.error(`Error sending SSE message to client:`, error);
+                    clients.delete(res);
+                }
+            }
+
+            // Clean up empty client sets
+            if (clients.size === 0) {
+                sseClients.delete(jobId);
+            }
+        }
+    }
+
+    function addSSEClient(jobId, res) {
+        if (!sseClients.has(jobId)) {
+            sseClients.set(jobId, new Set());
+        }
+        sseClients.get(jobId).add(res);
+    }
+
+    function removeSSEClient(jobId, res) {
+        if (sseClients.has(jobId)) {
+            const clients = sseClients.get(jobId);
+            clients.delete(res);
+            if (clients.size === 0) {
+                sseClients.delete(jobId);
+            }
+        }
+    }
+
+    // Session management utilities
+    async function createBrowserSession(sessionName = "Smart Browser Automation - CommonJS Session") {
+        console.log("🚀 Creating new browser session...");
+
+        const sessionResponse = await fetch('https://gridnew.doingerp.com/wd/hub/session', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                capabilities: {
+                    alwaysMatch: {
+                        browserName: "chrome",
+                        browserVersion: "128.0",
+                        "selenoid:options": {
+                            name: sessionName,
+                            sessionTimeout: "10m",
+                            enableVNC: true,
+                        },
+                        "goog:chromeOptions": {
+                            "args": ["--start-maximized"]
+                        }
+                    }
+                }
+            })
+        });
+
+        if (!sessionResponse.ok) {
+            throw new Error(`Failed to create session: ${sessionResponse.statusText}`);
+        }
+
+        const sessionData = await sessionResponse.json();
+        return sessionData.value.sessionId;
+    }
+
+    async function deleteBrowserSession(sessionId) {
+        try {
+            await fetch(`https://gridnew.doingerp.com/wd/hub/session/${sessionId}`, {
+                method: 'DELETE'
+            });
+            console.log(`✅ Session ${sessionId} deleted`);
+        } catch (error) {
+            console.log(`⚠️ Session cleanup failed for ${sessionId}:`, error.message);
+        }
+    }
+
+    // Configuration factory
+    function createLLMConfig(config = {}) {
+        //   const {
+        //       provider = 'ollama',
+        //       baseUrl = "https://api.z.ai/api/paas/v4",
+        //       model = "glm-4.5-flash",
+        //       apiKey = '27a8eae5c4fa43f4949a3e9c74032d8d.twI60j34Bjdsq41V',
+        //       temperature = 0.7,
+        //       topP = 0.9,
+        //       topK = 20,
+        //       minP = 0.0
+        //   } = config;
+        const {
+            provider = 'ollama',
+            baseUrl = "http://173.208.155.135:11434/v1",
+            model = "gpt-oss:20b",
+            apiKey = null,
+            temperature = 0.7,
+            topP = 0.9,
+            topK = 20,
+            minP = 0.0
+        } = config;
+
+        switch (provider.toLowerCase()) {
+            case 'huggingface':
+                return new HuggingFaceConfig(apiKey, model, {
+                    temperature,
+                    top_p: topP,
+                    top_k: topK,
+                    min_p: minP
+                });
+            case 'ollama':
+            default:
+                return new OllamaConfig(baseUrl, model, apiKey, 'openai', {
+                    temperature,
+                    top_p: topP,
+                    top_k: topK,
+                    min_p: minP
+                });
+        }
+    }
+
+    // Routes
+
+    /**
+     * POST /automation/execute
+     * Execute a browser automation task (asynchronous with job tracking)
+     */
+    router.post('/automation/execute', async (req, res) => {
+        const jobId = generateJobId();
+
+
+        try {
+            const {
+                task,
+                config = {},
+                maxSteps = 30,
+                temperature = 0.7,
+                verbose = true,
+                systemPrompt:BASE_SYSTEM_PROMPT,
+                sessionName,
+                async = true  // New parameter to control async behavior
+            } = req.body;
+
+            if (!task) {
+                return res.status(400).json({
+                    success: false,
+                    error: "Task description is required"
+                });
+            }
+
+            // Create job entry
+            const job = {
+                id: jobId,
+                status: JobStatus.PENDING,
+                task,
+                config,
+                maxSteps,
+                temperature,
+                verbose,
+                systemPrompt:BASE_SYSTEM_PROMPT,
+                sessionName,
+                createdAt: new Date(),
+                startedAt: null,
+                completedAt: null,
+                result: null,
+                error: null,
+                sessionId: null
+            };
+
+            runningJobs.set(jobId, job);
+
+            // If async mode, start job in background and return job ID immediately
+            if (async) {
+                // Start job in background
+                executeAutomationJob(jobId).catch(error => {
+                    console.error(`❌ Background job ${jobId} failed:`, error);
+                });
+
+                return res.json({
+                    success: true,
+                    jobId,
+                    message: "Job started successfully",
+                    status: JobStatus.PENDING,
+                    estimatedTime: "2-5 minutes",
+                    statusUrl: `/v1/job/${jobId}`,
+                    resultUrl: `/v1/job/${jobId}/result`
+                });
+            }
+
+            // Synchronous mode (for backward compatibility)
+            // Set a longer timeout for this request
+            req.setTimeout(10 * 60 * 1000); // 10 minutes
+            res.setTimeout(10 * 60 * 1000);
+
+            const result = await executeAutomationJob(jobId);
+
+            res.json({
+                success: true,
+                jobId,
+                sessionId: result.sessionId,
+                result: {
+                    completed: result.completed,
+                    steps: result.steps,
+                    success: result.success,
+                    results: result.results
+                }
+            });
+
+        } catch (error) {
+            console.error("❌ Error:", error);
+
+            // Update job status
+            if (runningJobs.has(jobId)) {
+                const job = runningJobs.get(jobId);
+                job.status = JobStatus.FAILED;
+                job.error = error.message;
+                job.completedAt = new Date();
+            }
+
+            res.status(500).json({
+                success: false,
+                error: error.message,
+                jobId,
+                stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
+            });
+        }
+    });
+
+    // Async job execution function
+    async function executeAutomationJob(jobId) {
+        const job = runningJobs.get(jobId);
+        if (!job) {
+            throw new Error(`Job ${jobId} not found`);
+        }
+
+        let sessionId = null;
+        let automation = null;
+
+        try {
+            // Update job status
+            job.status = JobStatus.RUNNING;
+            job.startedAt = new Date();
+
+            console.log(`🚀 Starting job ${jobId}: ${job.task.substring(0, 100)}...`);
+            sendSSEMessage(jobId, 'job_started', {
+                jobId,
+                message: `Starting job: ${job.task.substring(0, 100)}...`,
+                status: JobStatus.RUNNING
+            });
+
+            // Create browser session
+            sendSSEMessage(jobId, 'session_creating', {
+                message: 'Creating browser session...'
+            });
+
+            sessionId = await createBrowserSession(job.sessionName);
+            job.sessionId = sessionId;
+            console.log(`✅ Session created for job ${jobId}: ${sessionId}`);
+
+            sendSSEMessage(jobId, 'session_created', {
+                server: "https://gridnew.doingerp.com",
+                password: "selenoid",
+                sessionId,
+                message: `Browser session created: ${sessionId}`
+            });
+
+            // Configuration
+            const llmConfig = createLLMConfig(job.config);
+            const mcpEndpoint = job.config.mcpEndpoint || 'http://173.208.155.135:8931/sse';
+            const driverUrl = `wss://gridnew.doingerp.com/devtools/${sessionId}`;
+
+            // Create automation instance
+            automation = new SmartBrowserAutomation({
+                maxSteps: job.maxSteps,
+                temperature: job.temperature,
+                transportType: 'sse'
+            });
+
+            sendSSEMessage(jobId, 'automation_initializing', {
+                message: 'Initializing automation...'
+            });
+
+            // Initialize and execute
+            await automation.initialize(llmConfig, mcpEndpoint);
+            console.log(`✅ Automation initialized for job ${jobId}`);
+            const browserSetup = await automation.callTool("browser_connect_cdp", { endpoint: driverUrl });
+
+            sendSSEMessage(jobId, 'automation_initialized', {
+                message: 'Automation initialized successfully'
+            });
+
+            // Execute task with real-time updates
+            const result = await automation.executeTask(job.task, {
+                verbose: job.verbose,
+                systemPrompt: job.systemPrompt,
+                onProgress: async (progressData) => {
+                    // Send real-time updates via SSE
+                    sendSSEMessage(jobId, progressData.type, progressData);
+
+                    // Also log to console for server-side monitoring
+                    const time = new Date().toLocaleTimeString();
+                    switch (progressData.type) {
+                        case 'step_started':
+                            console.log(`🚀 Step ${progressData.step}: Starting...`);
+                            break;
+                        case 'tool_call':
+                            console.log(`🔧 LLM wants to use tool: ${progressData.toolName}`);
+                            console.log(`📝 Tool arguments:`, progressData.toolArgs);
+                            break;
+                        case 'tool_result':
+                            console.log(`✅ Tool executed successfully`);
+                            break;
+                        case 'tool_error':
+                            console.error(`❌ Tool execution failed:`, progressData.error);
+                            break;
+                        case 'task_completed':
+                            console.log(`🎯 Task completed! LLM response: ${progressData.response}`);
+                            break;
+                    }
+                }
+            });
+
+            // Update job with result
+            job.status = JobStatus.COMPLETED;
+            job.completedAt = new Date();
+            job.result = {
+                completed: result.completed,
+                steps: result.steps,
+                success: result.success,
+                results: result.results,
+                sessionId: sessionId
+            };
+
+            console.log(`🎉 Job ${jobId} completed successfully in ${job.result.steps} steps`);
+
+            sendSSEMessage(jobId, 'job_completed', {
+                jobId,
+                message: `Job completed successfully in ${job.result.steps} steps`,
+                status: JobStatus.COMPLETED,
+                result: job.result
+            });
+
+            return job.result;
+
+        } catch (error) {
+            console.error(`❌ Job ${jobId} failed:`, error);
+
+            // Update job with error
+            job.status = JobStatus.FAILED;
+            job.completedAt = new Date();
+            job.error = error.message;
+            job.result = {
+                success: false,
+                error: error.message,
+                sessionId: sessionId
+            };
+
+            sendSSEMessage(jobId, 'job_failed', {
+                jobId,
+                message: `Job failed: ${error.message}`,
+                status: JobStatus.FAILED,
+                error: error.message
+            });
+
+            throw error;
+        } finally {
+            // Clean up
+            if (automation) {
+                try {
+                    await automation.close();
+                    sendSSEMessage(jobId, 'automation_closed', {
+                        message: 'Automation instance closed'
+                    });
+                } catch (closeError) {
+                    console.error(`Error closing automation for job ${jobId}:`, closeError);
+                }
+            }
+            if (sessionId) {
+                await deleteBrowserSession(sessionId);
+                sendSSEMessage(jobId, 'session_deleted', {
+                    sessionId,
+                    message: 'Browser session cleaned up'
+                });
+            }
+
+            // Send final SSE message and clean up clients
+            sendSSEMessage(jobId, 'stream_ended', {
+                message: 'Real-time stream ended'
+            });
+
+            // Clean up SSE clients for this job after a delay
+            setTimeout(() => {
+                if (sseClients.has(jobId)) {
+                    const clients = sseClients.get(jobId);
+                    for (const res of clients) {
+                        try {
+                            res.end();
+                        } catch (error) {
+                            // Client already disconnected
+                        }
+                    }
+                    sseClients.delete(jobId);
+                }
+            }, 1000);
+        }
+    }
+
+    /**
+     * GET /job/:jobId/stream
+     * Real-time Server-Sent Events stream for job progress
+     */
+    router.get('/job/:jobId/stream', (req, res) => {
+        const { jobId } = req.params;
+
+        if (!runningJobs.has(jobId)) {
+            return res.status(404).json({
+                success: false,
+                error: "Job not found"
+            });
+        }
+
+        const job = runningJobs.get(jobId);
+
+        // Set up SSE headers
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Headers': 'Cache-Control'
+        });
+
+        // Send initial connection message
+        res.write(`data: ${JSON.stringify({
+            type: 'connected',
+            data: {
+                jobId,
+                status: job.status,
+                message: 'Real-time stream connected'
+            },
+            timestamp: new Date().toISOString()
+        })}\n\n`);
+
+        // If job is already completed, send the final result
+        if (job.status === JobStatus.COMPLETED) {
+            res.write(`data: ${JSON.stringify({
+                type: 'job_completed',
+                data: {
+                    jobId,
+                    status: job.status,
+                    result: job.result,
+                    message: 'Job already completed'
+                },
+                timestamp: new Date().toISOString()
+            })}\n\n`);
+
+            res.write(`data: ${JSON.stringify({
+                type: 'stream_ended',
+                data: { message: 'Stream ended - job already completed' },
+                timestamp: new Date().toISOString()
+            })}\n\n`);
+
+            return res.end();
+        }
+
+        // If job failed, send error and end
+        if (job.status === JobStatus.FAILED) {
+            res.write(`data: ${JSON.stringify({
+                type: 'job_failed',
+                data: {
+                    jobId,
+                    status: job.status,
+                    error: job.error,
+                    message: 'Job already failed'
+                },
+                timestamp: new Date().toISOString()
+            })}\n\n`);
+
+            res.write(`data: ${JSON.stringify({
+                type: 'stream_ended',
+                data: { message: 'Stream ended - job failed' },
+                timestamp: new Date().toISOString()
+            })}\n\n`);
+
+            return res.end();
+        }
+
+        // Add client to SSE clients list
+        addSSEClient(jobId, res);
+
+        // Handle client disconnect
+        req.on('close', () => {
+            removeSSEClient(jobId, res);
+        });
+
+        req.on('aborted', () => {
+            removeSSEClient(jobId, res);
+        });
+
+        // Keep connection alive with periodic ping
+        const pingInterval = setInterval(() => {
+            try {
+                res.write(`data: ${JSON.stringify({
+                    type: 'ping',
+                    data: { message: 'keepalive' },
+                    timestamp: new Date().toISOString()
+                })}\n\n`);
+            } catch (error) {
+                clearInterval(pingInterval);
+                removeSSEClient(jobId, res);
+            }
+        }, 30000); // Ping every 30 seconds
+
+        // Clean up interval when client disconnects
+        req.on('close', () => {
+            clearInterval(pingInterval);
+        });
+    });
+
+    /**
+     * GET /job/:jobId
+     * Get job status and information
+     */
+    router.get('/job/:jobId', (req, res) => {
+        const { jobId } = req.params;
+
+        if (!runningJobs.has(jobId)) {
+            return res.status(404).json({
+                success: false,
+                error: "Job not found"
+            });
+        }
+
+        const job = runningJobs.get(jobId);
+
+        // Calculate duration
+        let duration = null;
+        if (job.startedAt) {
+            const endTime = job.completedAt || new Date();
+            duration = Math.round((endTime - job.startedAt) / 1000); // seconds
+        }
+
+        res.json({
+            success: true,
+            job: {
+                id: job.id,
+                status: job.status,
+                task: job.task.substring(0, 200) + (job.task.length > 200 ? '...' : ''),
+                createdAt: job.createdAt,
+                startedAt: job.startedAt,
+                completedAt: job.completedAt,
+                duration: duration ? `${duration}s` : null,
+                sessionId: job.sessionId,
+                error: job.error
+            }
+        });
+    });
+
+    /**
+     * GET /job/:jobId/result
+     * Get job result (only available when completed)
+     */
+    router.get('/job/:jobId/result', (req, res) => {
+        const { jobId } = req.params;
+
+        if (!runningJobs.has(jobId)) {
+            return res.status(404).json({
+                success: false,
+                error: "Job not found"
+            });
+        }
+
+        const job = runningJobs.get(jobId);
+
+        if (job.status === JobStatus.PENDING || job.status === JobStatus.RUNNING) {
+            return res.status(202).json({
+                success: false,
+                error: "Job is still running",
+                status: job.status,
+                message: "Check back later for results"
+            });
+        }
+
+        if (job.status === JobStatus.FAILED) {
+            return res.status(500).json({
+                success: false,
+                error: job.error,
+                status: job.status
+            });
+        }
+
+        res.json({
+            success: true,
+            jobId: job.id,
+            status: job.status,
+            result: job.result
+        });
+    });
+
+    /**
+     * DELETE /job/:jobId
+     * Cancel a running job
+     */
+    router.delete('/job/:jobId', (req, res) => {
+        const { jobId } = req.params;
+
+        if (!runningJobs.has(jobId)) {
+            return res.status(404).json({
+                success: false,
+                error: "Job not found"
+            });
+        }
+
+        const job = runningJobs.get(jobId);
+
+        if (job.status === JobStatus.COMPLETED || job.status === JobStatus.FAILED) {
+            // Job already finished, just remove it
+            runningJobs.delete(jobId);
+            return res.json({
+                success: true,
+                message: "Job removed from history"
+            });
+        }
+
+        // Mark as cancelled (the actual execution will continue but won't be tracked)
+        job.status = JobStatus.CANCELLED;
+        job.completedAt = new Date();
+
+        res.json({
+            success: true,
+            message: "Job cancelled successfully"
+        });
+    });
+
+    /**
+     * GET /jobs
+     * Get all jobs with their status
+     */
+    router.get('/jobs', (req, res) => {
+        const { status, limit = 50 } = req.query;
+
+        let jobs = Array.from(runningJobs.values());
+
+        // Filter by status if provided
+        if (status) {
+            jobs = jobs.filter(job => job.status === status);
+        }
+
+        // Sort by creation time (newest first)
+        jobs.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
+
+        // Limit results
+        jobs = jobs.slice(0, parseInt(limit));
+
+        // Format jobs for response
+        const formattedJobs = jobs.map(job => {
+            let duration = null;
+            if (job.startedAt) {
+                const endTime = job.completedAt || new Date();
+                duration = Math.round((endTime - job.startedAt) / 1000);
+            }
+
+            return {
+                id: job.id,
+                status: job.status,
+                task: job.task.substring(0, 100) + (job.task.length > 100 ? '...' : ''),
+                createdAt: job.createdAt,
+                startedAt: job.startedAt,
+                completedAt: job.completedAt,
+                duration: duration ? `${duration}s` : null,
+                sessionId: job.sessionId
+            };
+        });
+
+        res.json({
+            success: true,
+            jobs: formattedJobs,
+            count: formattedJobs.length,
+            total: runningJobs.size
+        });
+    });
+
+    /**
+     * POST /session/create
+     * Create a new browser session for persistent operations
+     */
+    router.post('/session/create', async (req, res) => {
+        try {
+            const { sessionName, config = {} } = req.body;
+            const sessionId = await createBrowserSession(sessionName);
+
+            const sessionData = {
+                id: sessionId,
+                createdAt: new Date(),
+                status: 'active',
+                config: config,
+                lastActivity: new Date()
+            };
+
+            activeSessions.set(sessionId, sessionData);
+
+            res.json({
+                success: true,
+                sessionId,
+                message: "Session created successfully",
+                session: sessionData
+            });
+
+        } catch (error) {
+            console.error("❌ Error creating session:", error);
+            res.status(500).json({
+                success: false,
+                error: error.message
+            });
+        }
+    });
+
+    /**
+     * POST /session/:sessionId/execute
+     * Execute task on existing session
+     */
+    router.post('/session/:sessionId/execute', async (req, res) => {
+        const { sessionId } = req.params;
+        let automation = null;
+
+        try {
+            const {
+                task,
+                config = {},
+                maxSteps = 30,
+                temperature = 0.7,
+                verbose = true,
+                systemPrompt:BASE_SYSTEM_PROMPT
+            } = req.body;
+
+            if (!task) {
+                return res.status(400).json({
+                    success: false,
+                    error: "Task description is required"
+                });
+            }
+
+            if (!activeSessions.has(sessionId)) {
+                return res.status(404).json({
+                    success: false,
+                    error: "Session not found or expired"
+                });
+            }
+
+            // Update last activity
+            const sessionData = activeSessions.get(sessionId);
+            sessionData.lastActivity = new Date();
+
+            // Merge session config with request config
+            const mergedConfig = { ...sessionData.config, ...config };
+            const llmConfig = createLLMConfig(mergedConfig);
+
+            const mcpEndpoint = mergedConfig.mcpEndpoint || 'http://173.208.155.135:8931/sse';
+            const driverUrl = `wss://gridnew.doingerp.com/devtools/${sessionId}`;
+
+            // Create automation instance
+            automation = new SmartBrowserAutomation({
+                maxSteps,
+                temperature
+            });
+
+            // Initialize and execute
+            await automation.initialize(llmConfig, mcpEndpoint, driverUrl);
+            const result = await automation.executeTask(task, {
+                verbose,
+                systemPrompt
+            });
+
+            res.json({
+                success: true,
+                sessionId,
+                result: {
+                    completed: result.completed,
+                    steps: result.steps,
+                    success: result.success,
+                    results: result.results
+                }
+            });
+
+        } catch (error) {
+            console.error("❌ Error:", error);
+            res.status(500).json({
+                success: false,
+                error: error.message,
+                sessionId
+            });
+        } finally {
+            if (automation) {
+                try {
+                    await automation.close();
+                } catch (closeError) {
+                    console.error("Error closing automation:", closeError);
+                }
+            }
+        }
+    });
+
+    /**
+     * GET /session/:sessionId
+     * Get session information
+     */
+    router.get('/session/:sessionId', (req, res) => {
+        const { sessionId } = req.params;
+
+        if (!activeSessions.has(sessionId)) {
+            return res.status(404).json({
+                success: false,
+                error: "Session not found"
+            });
+        }
+
+        const sessionData = activeSessions.get(sessionId);
+        res.json({
+            success: true,
+            session: sessionData
+        });
+    });
+
+    /**
+     * DELETE /session/:sessionId
+     * Delete a browser session
+     */
+    router.delete('/session/:sessionId', async (req, res) => {
+        const { sessionId } = req.params;
+
+        try {
+            await deleteBrowserSession(sessionId);
+            activeSessions.delete(sessionId);
+
+            res.json({
+                success: true,
+                message: "Session deleted successfully"
+            });
+
+        } catch (error) {
+            console.error("❌ Error deleting session:", error);
+            res.status(500).json({
+                success: false,
+                error: error.message
+            });
+        }
+    });
+
+    /**
+     * GET /sessions
+     * Get all active sessions
+     */
+    router.get('/sessions', (req, res) => {
+        const sessions = Array.from(activeSessions.values());
+        res.json({
+            success: true,
+            sessions,
+            count: sessions.length
+        });
+    });
+
+    /**
+     * DELETE /sessions
+     * Clean up all sessions
+     */
+    router.delete('/sessions', async (req, res) => {
+        try {
+            const sessionIds = Array.from(activeSessions.keys());
+            const deletePromises = sessionIds.map(sessionId => deleteBrowserSession(sessionId));
+
+            await Promise.allSettled(deletePromises);
+            activeSessions.clear();
+
+            res.json({
+                success: true,
+                message: `Cleaned up ${sessionIds.length} sessions`,
+                deletedSessions: sessionIds
+            });
+
+        } catch (error) {
+            console.error("❌ Error cleaning up sessions:", error);
+            res.status(500).json({
+                success: false,
+                error: error.message
+            });
+        }
+    });
+
+    /**
+     * GET /health
+     * Health check endpoint
+     */
+    router.get('/health', (req, res) => {
+        res.json({
+            success: true,
+            message: "Smart Browser Automation CommonJS API is running",
+            timestamp: new Date(),
+            activeSessions: activeSessions.size,
+            uptime: process.uptime(),
+            version: "1.0.0-commonjs"
+        });
+    });
+
+    /**
+     * GET /config/providers
+     * Get available LLM providers
+     */
+    router.get('/config/providers', (req, res) => {
+        res.json({
+            success: true,
+            providers: [
+                {
+                    name: 'ollama',
+                    description: 'Ollama local or remote server',
+                    defaultModel: 'openrouter/horizon-beta',
+                    requiresApiKey: true
+                },
+                {
+                    name: 'huggingface',
+                    description: 'Hugging Face Inference API',
+                    defaultModel: 'Qwen/Qwen3-Coder-480B-A35B-Instruct',
+                    requiresApiKey: true
+                }
+            ]
+        });
+    });
+
+    // Error handling middleware
+    router.use((error, req, res, next) => {
+        console.error('Unhandled error:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Internal server error',
+            message: error.message,
+            stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
+        });
+    });
+
+    // Return the configured router
+    return router;
+}
+
+// Create a middleware function that initializes the router on first use
+module.exports = (function () {
+    let routerPromise = null;
+    let router = null;
+
+    return function (req, res, next) {
+        if (router) {
+            // Router already initialized, use it directly
+            return router(req, res, next);
+        }
+
+        if (!routerPromise) {
+            // Initialize router on first request
+            routerPromise = createRouter().then(r => {
+                router = r;
+                return r;
+            });
+        }
+
+        // Wait for router to be ready and then handle the request
+        routerPromise
+            .then(r => r(req, res, next))
+            .catch(next);
+    };
+})();