@yusufffararatt/dombridge-mcp 2.7.5

package/src/bridge/http-server.js

@@ -0,0 +1,290 @@
+/**
+ * HTTP Bridge Server Setup
+ * Express server with Singleton Gateway, Heartbeat, and Graceful Shutdown
+ *
+ * Improvements:
+ * - Singleton pattern: prevents port conflicts between multiple agent instances
+ * - Heartbeat tracking: detects stale connections automatically
+ * - Graceful shutdown: properly closes connections on SIGINT/SIGTERM
+ * - Connection health logging: timestamps for diagnostics
+ */
+
+import express from 'express';
+import { setupMiddleware, errorHandler } from './middleware.js';
+import { setupRoutes } from './routes.js';
+import {
+  CONNECTION_STALE_TIMEOUT_MS,
+  STALE_MONITOR_CHECK_INTERVAL_MS,
+  HEALTH_CHECK_FETCH_TIMEOUT_MS,
+  CONNECTION_HEALTH_MAX_EVENTS,
+} from '../constants.js';
+import { logger } from '../utils/logger.js';
+import { clearAllPendingRequests } from '../state/extension-state.js';
+import { persistStateNow } from '../state/bridge-persistence.js';
+
+/**
+ * Connection health tracker
+ * Monitors extension heartbeats and detects stale connections
+ */
+export const connectionHealth = {
+  lastHeartbeat: null,
+  heartbeatCount: 0,
+  connectionStartedAt: null,
+  disconnectedAt: null,
+  reconnectCount: 0,
+  staleTimeoutMs: CONNECTION_STALE_TIMEOUT_MS,
+  events: [],           // last CONNECTION_HEALTH_MAX_EVENTS connection events
+  currentSessionId: null,
+  knownSessionIds: new Set(), // Track all ever-seen session IDs to avoid multi-tab false reconnects
+  serverStartedAt: Date.now(), // Phase 1.4: Server start timestamp for restart detection
+
+  recordHeartbeat(sessionId = null) {
+    const now = Date.now();
+    const wasStale = this.isStale();
+    // Only count as "new session" if this session ID has NEVER been seen before
+    const isNewSession = sessionId && !this.knownSessionIds.has(sessionId);
+
+    this.lastHeartbeat = now;
+    this.heartbeatCount++;
+    if (sessionId) {
+      this.knownSessionIds.add(sessionId);
+      // Cleanup: cap at 100 to prevent unbounded growth
+      if (this.knownSessionIds.size > 100) {
+        const iter = this.knownSessionIds.values();
+        for (let i = 0; i < 50; i++) {
+          this.knownSessionIds.delete(iter.next().value);
+        }
+      }
+      this.currentSessionId = sessionId;
+    }
+
+    if (!this.connectionStartedAt || wasStale || isNewSession) {
+      // New connection, reconnection after stale, or truly new page session
+      if (this.connectionStartedAt && (wasStale || isNewSession)) {
+        this.reconnectCount++;
+        this.addEvent(isNewSession ? 'new-session' : 'reconnected');
+      } else {
+        this.addEvent('connected');
+      }
+      this.connectionStartedAt = now;
+      this.disconnectedAt = null;
+    }
+  },
+
+  isStale() {
+    if (!this.lastHeartbeat) return true;
+    return (Date.now() - this.lastHeartbeat) > this.staleTimeoutMs;
+  },
+
+  markDisconnected(reason = 'timeout') {
+    this.disconnectedAt = Date.now();
+    this.addEvent(`disconnected:${reason}`);
+  },
+
+  addEvent(type) {
+    this.events.push({
+      type,
+      timestamp: Date.now(),
+      time: new Date().toISOString()
+    });
+    if (this.events.length > CONNECTION_HEALTH_MAX_EVENTS) {
+      this.events.shift();
+    }
+  },
+
+  getStatus() {
+    const stale = this.isStale();
+    const uptimeMs = this.connectionStartedAt
+      ? Date.now() - this.connectionStartedAt
+      : 0;
+    const lastHeartbeatAge = this.lastHeartbeat
+      ? Math.floor((Date.now() - this.lastHeartbeat) / 1000)
+      : null;
+
+    return {
+      connected: !stale && !!this.lastHeartbeat,
+      stale,
+      lastHeartbeat: this.lastHeartbeat
+        ? new Date(this.lastHeartbeat).toISOString()
+        : null,
+      lastHeartbeatAge,
+      heartbeatCount: this.heartbeatCount,
+      uptimeMs,
+      uptimeHuman: formatUptime(uptimeMs),
+      reconnectCount: this.reconnectCount,
+      currentSessionId: this.currentSessionId,
+      knownSessionCount: this.knownSessionIds.size,
+      recentEvents: this.events.slice(-5)
+    };
+  }
+};
+
+function formatUptime(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  const secs = Math.floor(ms / 1000);
+  if (secs < 60) return `${secs}s`;
+  const mins = Math.floor(secs / 60);
+  if (mins < 60) return `${mins}m ${secs % 60}s`;
+  const hours = Math.floor(mins / 60);
+  return `${hours}h ${mins % 60}m`;
+}
+
+/**
+ * Stale connection monitor
+ * Periodically checks if extension connection is alive
+ */
+let staleCheckInterval = null;
+
+function startStaleMonitor(extensionData) {
+  if (staleCheckInterval) clearInterval(staleCheckInterval);
+
+  staleCheckInterval = setInterval(() => {
+    if (connectionHealth.lastHeartbeat && connectionHealth.isStale()) {
+      if (extensionData.isConnected) {
+        extensionData.isConnected = false;
+        clearAllPendingRequests(extensionData);
+        connectionHealth.markDisconnected('timeout');
+        logger.warn('Bridge', `Extension connection stale (no heartbeat for ${Math.round(CONNECTION_STALE_TIMEOUT_MS/1000)}s) — pending requests cleared`);
+      }
+    }
+  }, STALE_MONITOR_CHECK_INTERVAL_MS);
+}
+
+/**
+ * Check if existing instance is healthy
+ */
+async function checkExistingInstance(port) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), HEALTH_CHECK_FETCH_TIMEOUT_MS);
+    const response = await fetch(`http://localhost:${port}/health`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (response.ok) {
+      const data = await response.json();
+      return data;
+    }
+  } catch {
+    // Not responding
+  }
+  return null;
+}
+
+export const createHttpServer = (port) => {
+  const app = express();
+
+  // Middleware'leri kur
+  setupMiddleware(app);
+
+  // Route'ları kur
+  setupRoutes(app, port);
+
+  // Error handler
+  app.use(errorHandler);
+
+  return app;
+};
+
+export const startHttpServer = async (app, port, extensionData) => {
+  let isSecondary = false;
+  let httpServer = null;
+
+  // Check if port is already in use
+  const existingHealth = await checkExistingInstance(port);
+
+  if (existingHealth && existingHealth.status === 'ok') {
+    logger.debug('Bridge', `Existing instance on port ${port}, terminating...`);
+    try {
+      await fetch(`http://localhost:${port}/api/die`, { method: 'POST' }).catch(() => {});
+      await new Promise(r => setTimeout(r, 1000));
+    } catch (e) {
+      logger.debug('Bridge', 'Failed to kill existing instance:', e);
+    }
+  }
+
+  // Try to start as primary
+  httpServer = await new Promise((resolve) => {
+    const server = app.listen(port, '127.0.0.1', () => {
+      logger.info('Bridge', `HTTP server started on port ${port} (PRIMARY)`);
+      connectionHealth.addEvent('server:started');
+      resolve(server);
+    });
+
+    server.on('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        isSecondary = true;
+        connectionHealth.addEvent('secondary:port-conflict');
+        logger.warn('Bridge', `Port ${port} still busy — running as SECONDARY`);
+        resolve(null);
+      } else {
+        connectionHealth.addEvent(`error:${err.code}`);
+        resolve(null);
+      }
+    });
+  });
+
+  // Only monitor stale connections if we are the primary server
+  if (!isSecondary && httpServer) {
+    startStaleMonitor(extensionData);
+  }
+
+  // Setup graceful shutdown
+  setupGracefulShutdown(httpServer, extensionData);
+
+  return { httpServer, isSecondary };
+};
+
+/**
+ * Graceful Shutdown Handler
+ * Properly closes HTTP server and cleans up resources
+ */
+function setupGracefulShutdown(httpServer, extensionData) {
+  let isShuttingDown = false;
+
+  const shutdown = (signal) => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+
+    logger.info('Bridge', `${signal} received — shutting down gracefully...`);
+
+    connectionHealth.addEvent(`shutdown:${signal}`);
+
+    // Phase 1.1: Persist state before shutdown
+    try {
+      persistStateNow(extensionData);
+      logger.info('Bridge', 'State persisted before shutdown');
+    } catch (err) {
+      logger.warn('Bridge', 'Failed to persist state before shutdown:', err.message);
+    }
+
+    // Stop stale monitor
+    if (staleCheckInterval) {
+      clearInterval(staleCheckInterval);
+      staleCheckInterval = null;
+    }
+
+    // Close HTTP server
+    if (httpServer) {
+      httpServer.close(() => {
+        logger.info('Bridge', 'HTTP server closed');
+        process.exit(0);
+      });
+
+      // Force exit after 5 seconds
+      setTimeout(() => {
+        process.exit(0);
+      }, 5000);
+    } else {
+      process.exit(0);
+    }
+  };
+
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+
+  // Windows does not support SIGTERM
+  if (process.platform === 'win32') {
+    process.on('SIGHUP', () => shutdown('SIGHUP'));
+  }
+}

package/src/bridge/middleware.js

@@ -0,0 +1,56 @@
+/**
+ * HTTP Bridge Middleware
+ * CORS, error handling ve diğer middleware'ler
+ */
+
+import cors from 'cors';
+import express from 'express';
+
+export const setupMiddleware = (app) => {
+  // CORS - Only allow localhost and Chrome extensions (not arbitrary origins)
+  app.use(cors({
+    origin: (origin, callback) => {
+      if (
+        !origin ||
+        origin === 'null' ||
+        /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin) ||
+        /^chrome-extension:\/\//.test(origin)
+      ) {
+        callback(null, true);
+      } else {
+        callback(new Error('CORS: origin not allowed'));
+      }
+    }
+  }));
+
+  // JSON parsing — per-route limits (single middleware, no global pre-parse)
+  // Global express.json() is intentionally absent: it would reject large payloads before route checks run.
+  const smallJson  = express.json({ limit: '4kb' });   // default — unknown/small endpoints
+  const mediumJson = express.json({ limit: '1mb' });   // execute-js/action/screenshot
+  const largeJson  = express.json({ limit: '50mb' });  // network-trace/sync-all/websocket-trace
+  const largePaths  = ['/api/network-trace', '/api/sync-all', '/api/websocket-trace', '/api/page-analysis', '/api/element-selected'];
+  const mediumPaths = ['/api/execute-js', '/api/execute-action', '/api/capture-screenshot', '/api/export-session', '/api/raw-network-requests', '/api/analyze-page'];
+  app.use((req, res, next) => {
+    if (largePaths.includes(req.path))  return largeJson(req, res, next);
+    if (mediumPaths.includes(req.path)) return mediumJson(req, res, next);
+    return smallJson(req, res, next);
+  });
+
+  // Request logging (Muted for MCP Stdio JSON-RPC compatibility)
+  app.use((req, res, next) => {
+    /*
+    if (req.path !== '/health') {
+      console.error(`[MCP Bridge] ${req.method} ${req.path}`);
+    }
+    */
+    next();
+  });
+};
+
+export const errorHandler = (err, req, res, _next) => {
+  console.error('[MCP Bridge] Error:', err.message);
+  res.status(500).json({
+    success: false,
+    error: err.message
+  });
+};