@yusufffararatt/dombridge-mcp 2.7.5

package/src/bridge/routes.js

@@ -0,0 +1,1003 @@
+/**
+ * HTTP Bridge Routes
+ * Extension ile iletişim için API endpoints
+ */
+
+import {
+  extensionData,
+  updateSelectedElement,
+  updateNetworkTrace,
+  updateWebSocketTrace,
+  updateSavedSelections,
+  updatePageAnalysis,
+  syncAll,
+  updateConnection,
+  updateDisconnect,
+  addCapturedEndpoint
+} from '../state/extension-state.js';
+import { connectionHealth } from './http-server.js';
+import { resetAllCircuitBreakers } from '../utils/circuit-breaker.js';
+import { logger } from '../utils/logger.js';
+import { persistStateNow } from '../state/bridge-persistence.js';
+import { MetricsDB } from '../metrics/metrics-db.js';
+import { spawn } from 'child_process';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+// Shared MetricsDB instance for connection event recording
+const metricsDB = new MetricsDB();
+
+// Track last known session ID to detect page refreshes
+let lastSessionId = null;
+
+// Captured auth tokens: domain → token value
+const capturedAuthTokens = {};
+
+export const setupRoutes = (app, httpPort) => {
+  /**
+   * Health check endpoint
+   */
+  app.get('/health', (req, res) => {
+    const uptimeSeconds = Math.floor(process.uptime());
+    const health = connectionHealth.getStatus();
+    res.json({
+      status: 'ok',
+      isConnected: health.connected,
+      lastUpdate: extensionData.lastUpdateTime,
+      hasData: !!extensionData.selectedElement,
+      httpPort: httpPort,
+      uptime: `${uptimeSeconds}s`,
+      connection: health,
+      dataState: {
+        selectedElement: !!extensionData.selectedElement,
+        networkMatches: extensionData.networkTrace.totalMatches,
+        savedSelections: extensionData.savedSelections.length
+      }
+    });
+  });
+
+  /**
+   * State sync endpoint for secondary instances
+   */
+  app.get('/api/sync-state', (req, res) => {
+    // exportSessionResult, jsExecutionResult, captureScreenshotResult kasıtlı olarak dışarıda —
+    // bu field'lar raw cookie, token ve kod çıktısı içerebilir; reconnect için gerekli değil.
+    res.json({
+      selectedElement: extensionData.selectedElement,
+      networkTrace: extensionData.networkTrace,
+      websocketTrace: extensionData.websocketTrace,
+      websocketConnections: extensionData.websocketConnections,
+      pageAnalysis: extensionData.pageAnalysis,
+      savedSelections: extensionData.savedSelections,
+      isConnected: extensionData.isConnected,
+      lastUpdateTime: extensionData.lastUpdateTime,
+      apiEndpoints: extensionData.apiEndpoints  // NEW: for manage_site_profile save flow
+    });
+  });
+
+  /**
+   * Extension'dan element seçimi aldığında
+   */
+  app.post('/api/element-selected', (req, res) => {
+    updateSelectedElement(req.body);
+    res.json({ success: true });
+  });
+
+  /**
+   * Extension'dan network trace aldığında
+   */
+  app.post('/api/network-trace', (req, res) => {
+    updateNetworkTrace(req.body);
+    res.json({ success: true });
+  });
+
+  /**
+   * Extension'dan WebSocket trace aldığında (NEW v2.3)
+   */
+  app.post('/api/websocket-trace', (req, res) => {
+    updateWebSocketTrace(req.body);
+    res.json({ success: true });
+  });
+
+  /**
+   * Extension'dan kaydedilmiş seçimleri aldığında
+   */
+  app.post('/api/saved-selections', (req, res) => {
+    updateSavedSelections(req.body.savedSelections);
+    res.json({ success: true });
+  });
+
+  /**
+   * MCP-side tool (discover_apis / execute_js capture) pushes a captured
+   * endpoint into bridge state. Dedupe happens inside addCapturedEndpoint.
+   * Returns the persisted entry so the caller can update its local cache.
+   */
+  app.post('/api/captured-endpoint', (req, res) => {
+    const { domain, method, url, status, contentType } = req.body || {};
+    if (!domain || !url) {
+      return res.status(400).json({ success: false, error: 'domain_and_url_required' });
+    }
+    addCapturedEndpoint({ domain, method, url, status, contentType });
+    const entry = extensionData.apiEndpoints.find(
+      (e) => e.domain === domain && e.url === url
+    );
+    res.json({ success: true, entry: entry || null });
+  });
+
+  /**
+   * Tüm state'i bir seferde sync etmek için
+   */
+  app.post('/api/sync-all', (req, res) => {
+    syncAll(req.body);
+    res.json({ success: true });
+  });
+
+  /**
+   * Phase 1.2: Full-sync endpoint — extension pushes all state after server restart
+   * This is called when the extension detects serverStartedAt has changed,
+   * meaning the MCP server restarted and lost all in-memory state.
+   */
+  app.post('/api/full-sync', (req, res) => {
+    const { selectedElement, networkTrace, websocketConnections, pageAnalysis, savedSelections, sessionId, pageUrl } = req.body;
+
+    if (selectedElement) {
+      updateSelectedElement(selectedElement);
+    }
+
+    if (networkTrace) {
+      updateNetworkTrace(networkTrace);
+    }
+
+    if (websocketConnections) {
+      updateWebSocketTrace(websocketConnections);
+    }
+
+    if (pageAnalysis) {
+      updatePageAnalysis(pageAnalysis);
+    }
+
+    if (savedSelections && savedSelections.length > 0) {
+      updateSavedSelections(savedSelections);
+    }
+
+    if (sessionId) {
+      updateConnection(sessionId);
+    }
+
+    if (pageUrl) {
+      extensionData.activeTabUrl = pageUrl;
+    }
+
+    extensionData.isConnected = true;
+    extensionData.lastUpdateTime = Date.now();
+
+    logger.info('Bridge', 'Full-sync received from extension after server restart');
+    res.json({ success: true, message: 'Full state sync received' });
+  });
+
+  /**
+   * Extension connection test
+   */
+  app.post('/api/ping', (req, res) => {
+    updateConnection();
+    connectionHealth.recordHeartbeat();
+    res.json({ pong: true, health: connectionHealth.getStatus() });
+  });
+
+  /**
+   * Lightweight heartbeat endpoint
+   * Extension calls this every 15s to keep connection alive
+   */
+  app.post('/api/heartbeat', (req, res) => {
+    const { sessionId, pageUrl } = req.body;
+
+    // Detect page refresh: new session ID means the page reloaded
+    const isNewSession = sessionId && lastSessionId && sessionId !== lastSessionId;
+    if (sessionId) lastSessionId = sessionId;
+    if (pageUrl) extensionData.activeTabUrl = pageUrl;
+
+    // Circuit breaker reset: if extension reconnects after disconnect,
+    // breakers that tripped during the outage should not block new requests.
+    if (isNewSession) {
+      resetAllCircuitBreakers();
+    }
+
+    updateConnection(sessionId || null);
+    connectionHealth.recordHeartbeat(sessionId || null);
+
+    // Return any pending requests so extension can process them
+    const pendingCount =
+      (extensionData.jsExecutionRequest ? 1 : 0) +
+      (extensionData.actionExecutionRequest ? 1 : 0) +
+      (extensionData.captureScreenshotRequest ? 1 : 0) +
+      (extensionData.rawNetworkRequests?.length || 0) +
+      (extensionData.analyzePageRequests?.length || 0) +
+      (extensionData.selectElementRequest ? 1 : 0);
+
+    // If new session detected and server has a previous element selection, ask extension to restore it
+    let needsRestore = isNewSession && !!extensionData.selectedElement;
+
+    // Tab navigation: clear pendingNavigation flag and signal restore if element exists
+    if (extensionData.pendingNavigation) {
+      extensionData.pendingNavigation = false;
+      if (!needsRestore && extensionData.selectedElement) {
+        needsRestore = true;
+      }
+    }
+
+    const response = {
+      alive: true,
+      pendingRequests: pendingCount,
+      serverUptime: Math.floor(process.uptime()),
+      serverStartedAt: connectionHealth.serverStartedAt // Phase 1.4: restart detection
+    };
+
+    if (needsRestore) {
+      response.needsRestore = true;
+      response.selectedElement = extensionData.selectedElement;
+    }
+
+    res.json(response);
+  });
+
+  /**
+   * Explicit disconnect from extension (page unload, tab close)
+   */
+  app.post('/api/disconnect', (req, res) => {
+    const { reason } = req.body;
+    updateDisconnect(reason || 'page-unload');
+    connectionHealth.markDisconnected(reason || 'page-unload');
+    res.json({ success: true });
+  });
+
+  /**
+   * Soft disconnect — tab navigation signal
+   * Unlike /api/disconnect, this does NOT set isConnected=false.
+   * Instead sets pendingNavigation=true so heartbeat can restore state.
+   */
+  app.post('/api/soft-disconnect', (req, res) => {
+    const { tabId } = req.body;
+    extensionData.pendingNavigation = true;
+    logger.debug('Bridge', `Soft disconnect (tab navigation, tabId=${tabId})`);
+    res.json({ success: true });
+  });
+
+  /**
+   * Sayfa veri kaynağı analizi
+   */
+  app.post('/api/page-analysis', (req, res) => {
+    updatePageAnalysis(req.body);
+    res.json({ success: true });
+  });
+
+  /**
+   * JavaScript Execution Endpoint
+   * Extension'dan gelen JS execution requestlerini handle eder
+   */
+  app.post('/api/execute-js', (req, res) => {
+    const { code, timeout, result } = req.body;
+
+    if (result !== undefined) {
+      // Extension'dan sonuç geldi, requestId-keyed map'e kaydet (race-condition fix)
+      const rid = req.body.requestId || req.body.id || `js-${Date.now()}`;
+      extensionData.jsExecutionResults = extensionData.jsExecutionResults || {};
+      extensionData.jsExecutionResults[rid] = {
+        code,
+        result,
+        timestamp: new Date().toISOString(),
+        requestId: rid,
+        ...(req.body.__typeHint ? { __typeHint: req.body.__typeHint } : {})
+      };
+      res.json({ success: true });
+    } else {
+      // MCP'den gelen execution request - extension'a forward et
+      extensionData.jsExecutionRequest = {
+        code,
+        timeout: timeout || 5000,
+        id: req.body.id || req.body.requestId || `js-${Date.now()}`,
+        timestamp: new Date().toISOString(),
+        context: req.body.context || 'page',
+        ...(req.body.tabId ? { tabId: req.body.tabId } : {})
+      };
+      res.json({ success: true, queued: true });
+    }
+  });
+
+
+
+
+
+  /**
+   * RPA Action Endpoint
+   * MCP'den gelen RPA actions'ı (click, type, navigate) queue'lar
+   */
+  app.post('/api/execute-action', (req, res) => {
+    const { actionType, selectorInfo, text, url, result } = req.body;
+
+    if (result !== undefined) {
+      // Extension'dan sonuç geldi, state'e kaydet
+      extensionData.actionExecutionResult = {
+        actionType,
+        result,
+        timestamp: new Date().toISOString(),
+        requestId: req.body.requestId || req.body.id
+      };
+      res.json({ success: true });
+    } else {
+      // MCP'den gelen action request - extension'a forward et
+      extensionData.actionExecutionRequest = {
+        actionType,
+        selectorInfo,
+        text,
+        url,
+        id: req.body.id || req.body.requestId || `action-${Date.now()}`,
+        timestamp: new Date().toISOString(),
+        ...(req.body.tabId ? { tabId: req.body.tabId } : {})
+      };
+      res.json({ success: true, queued: true });
+    }
+  });
+
+  /**
+   * Analyze Page Endpoint
+   * MCP tool page analysis request'lerini kuyruğa alır; extension sonucu buraya gönderir.
+   */
+  app.post('/api/analyze-page', (req, res) => {
+    const { result } = req.body;
+
+    if (result !== undefined) {
+      const requestId = req.body.requestId || req.body.id;
+      if (requestId) {
+        extensionData.analyzePageResults[requestId] = {
+          result,
+          timestamp: new Date().toISOString(),
+          requestId
+        };
+      }
+      res.json({ success: true });
+    } else {
+      const queuedRequest = {
+        id: req.body.id || req.body.requestId || `analyze-${Date.now()}`,
+        timestamp: new Date().toISOString(),
+        ...(req.body.tabId ? { tabId: req.body.tabId } : {})
+      };
+      extensionData.analyzePageRequests.push(queuedRequest);
+      res.json({ success: true, queued: true });
+    }
+  });
+
+  /**
+   * Screenshot Endpoint
+   * MCP'den gelen viewport screenshot işlemlerini sıraya alır
+   */
+  app.post('/api/capture-screenshot', (req, res) => {
+    const { result } = req.body;
+
+    if (result !== undefined) {
+      if (result.error) {
+        extensionData.captureScreenshotResult = {
+          error: result.error,
+          timestamp: new Date().toISOString(),
+          requestId: req.body.requestId || req.body.id
+        };
+      } else {
+        extensionData.captureScreenshotResult = {
+          dataUrl: result.dataUrl,
+          timestamp: new Date().toISOString(),
+          requestId: req.body.requestId || req.body.id
+        };
+      }
+      res.json({ success: true });
+    } else {
+      extensionData.captureScreenshotRequest = {
+        id: req.body.id || req.body.requestId || `screenshot-${Date.now()}`,
+        timestamp: new Date().toISOString(),
+        ...(req.body.tabId ? { tabId: req.body.tabId } : {})
+      };
+      res.json({ success: true, queued: true });
+    }
+  });
+
+  /**
+   * Polling Endpoint: Bekleyen request'leri döndürür
+   * Extension bu endpoint'i periyodik olarak check eder
+   */
+  app.get('/api/pending-requests', (req, res) => {
+    const pendingRequests = [];
+
+    // JS execution request varsa
+    if (extensionData.jsExecutionRequest) {
+      pendingRequests.push({
+        type: 'execute_js',
+        data: extensionData.jsExecutionRequest
+      });
+    }
+
+
+
+    // RPA Action request varsa
+    if (extensionData.actionExecutionRequest) {
+      pendingRequests.push({
+        type: 'execute_action',
+        data: extensionData.actionExecutionRequest
+      });
+    }
+
+    // Screenshot request varsa
+    if (extensionData.captureScreenshotRequest) {
+      pendingRequests.push({
+        type: 'capture_screenshot',
+        data: extensionData.captureScreenshotRequest
+      });
+    }
+
+    // Raw network discovery request varsa
+    for (const request of (extensionData.rawNetworkRequests || [])) {
+      pendingRequests.push({
+        type: 'get_raw_network',
+        data: request
+      });
+    }
+
+    // Analyze page requests varsa
+    for (const request of (extensionData.analyzePageRequests || [])) {
+      pendingRequests.push({
+        type: 'analyze_page',
+        data: request
+      });
+    }
+
+    // Programmatic element selection request varsa
+    if (extensionData.selectElementRequest) {
+      pendingRequests.push({
+        type: 'select_element',
+        data: extensionData.selectElementRequest
+      });
+    }
+
+    // Export session request varsa
+    if (extensionData.exportSessionRequest) {
+      pendingRequests.push({
+        type: 'export_session',
+        data: extensionData.exportSessionRequest
+      });
+    }
+
+    // Tab list request varsa
+    if (extensionData.tabsRequest) {
+      pendingRequests.push({
+        type: 'get_tabs',
+        data: extensionData.tabsRequest
+      });
+    }
+
+    res.json({
+      success: true,
+      hasPending: pendingRequests.length > 0,
+      requests: pendingRequests
+    });
+  });
+
+  /**
+   * Raw Network Discovery Endpoint (discover_apis tool)
+   * MCP tool bir raw network keşfi kuyruğa alır; extension sonucu buraya gönderir.
+   */
+  app.post('/api/raw-network-requests', (req, res) => {
+    const { result } = req.body;
+
+    if (result !== undefined) {
+      // Extension'dan sonuç geldi
+      const requestId = req.body.requestId || req.body.id;
+      extensionData.rawNetworkResults[requestId] = {
+        requests: result.requests || [],
+        total: result.total || 0,
+        error: result.error || null,
+        timestamp: new Date().toISOString(),
+        requestId
+      };
+      res.json({ success: true });
+    } else {
+      // MCP tool'dan request — extension'a forward et
+      extensionData.rawNetworkRequests.push({
+        urlPattern: req.body.urlPattern || null,
+        method: req.body.method || 'all',
+        limit: req.body.limit || 50,
+        includeBody: req.body.includeBody || false,
+        id: req.body.id || `raw-net-${Date.now()}`,
+        timestamp: new Date().toISOString(),
+        ...(req.body.tabId ? { tabId: req.body.tabId } : {})
+      });
+      res.json({ success: true, queued: true });
+    }
+  });
+
+  /**
+   * Programmatic Element Selection Endpoint (select_element tool)
+   * MCP tool bir selector iletir; extension elementi bulup /api/element-selected'a gönderir.
+   */
+  app.post('/api/select-element', (req, res) => {
+    const { result } = req.body;
+
+    if (result !== undefined) {
+      // Extension'dan selection sonucu geldi (hata veya başarı)
+      extensionData.selectElementResult = {
+        success: result.success || false,
+        error: result.error || null,
+        element: result.element || null,
+        timestamp: new Date().toISOString(),
+        requestId: req.body.requestId || req.body.id
+      };
+      res.json({ success: true });
+    } else {
+      // MCP tool'dan selector request — extension'a forward et
+      extensionData.selectElementRequest = {
+        selectorInfo: req.body.selectorInfo,
+        triggerNetworkTrace: req.body.triggerNetworkTrace !== false,
+        id: req.body.id || `sel-elem-${Date.now()}`,
+        timestamp: new Date().toISOString(),
+        ...(req.body.tabId ? { tabId: req.body.tabId } : {})
+      };
+      res.json({ success: true, queued: true });
+    }
+  });
+
+  /**
+   * Clear Pending Request: Extension request'i çalıştırdıktan sonra temizler
+   */
+  app.post('/api/clear-request', (req, res) => {
+    const { type, requestId } = req.body;
+
+    if (type === 'execute_js' && extensionData.jsExecutionRequest?.id === requestId) {
+      extensionData.jsExecutionRequest = null;
+    }
+
+    if (type === 'execute_action' && extensionData.actionExecutionRequest?.id === requestId) {
+      extensionData.actionExecutionRequest = null;
+    }
+
+    if (type === 'capture_screenshot' && extensionData.captureScreenshotRequest?.id === requestId) {
+      extensionData.captureScreenshotRequest = null;
+    }
+
+    if (type === 'get_raw_network') {
+      extensionData.rawNetworkRequests = (extensionData.rawNetworkRequests || [])
+        .filter(request => request.id !== requestId);
+    }
+
+    if (type === 'analyze_page') {
+      extensionData.analyzePageRequests = (extensionData.analyzePageRequests || [])
+        .filter(request => request.id !== requestId);
+    }
+
+    if (type === 'select_element' && extensionData.selectElementRequest?.id === requestId) {
+      extensionData.selectElementRequest = null;
+    }
+
+    if (type === 'export_session' && extensionData.exportSessionRequest?.id === requestId) {
+      extensionData.exportSessionRequest = null;
+    }
+
+    if (type === 'get_tabs' && extensionData.tabsRequest?.id === requestId) {
+      extensionData.tabsRequest = null;
+    }
+
+    res.json({ success: true });
+  });
+
+  /**
+   * Export Session Endpoint
+   * MCP tool bir export_session isteği kuyruğa alır; extension cookie+storage okuyup sonucu buraya gönderir.
+   */
+  app.post('/api/export-session', (req, res) => {
+    const { result, error } = req.body;
+
+    if (result !== undefined || error !== undefined) {
+      // Extension'dan sonuç geldi
+      extensionData.exportSessionResult = {
+        result: result || null,
+        error: error || null,
+        timestamp: new Date().toISOString(),
+        requestId: req.body.requestId || req.body.id
+      };
+      res.json({ success: true });
+    } else {
+      // MCP tool'dan request — extension'a forward et
+      extensionData.exportSessionRequest = {
+        id: req.body.id || `export-session-${Date.now()}`,
+        timestamp: new Date().toISOString(),
+        ...(req.body.tabId ? { tabId: req.body.tabId } : {})
+      };
+      res.json({ success: true, queued: true });
+    }
+  });
+
+  /**
+   * Tab List Endpoint (multi-tab support)
+   * Extension service worker'dan tab listesini çeker; debug_mcp_state ve tabId targeting için kullanılır.
+   */
+  app.post('/api/tabs', (req, res) => {
+    const { result } = req.body;
+
+    if (result !== undefined) {
+      // Extension'dan sonuç geldi
+      extensionData.tabsResult = {
+        tabs: result.tabs || [],
+        timestamp: new Date().toISOString(),
+        requestId: req.body.requestId || req.body.id
+      };
+      res.json({ success: true });
+    } else {
+      // MCP tool'dan request — extension'a forward et
+      extensionData.tabsRequest = {
+        id: req.body.id || `tabs-${Date.now()}`,
+        timestamp: new Date().toISOString()
+      };
+      res.json({ success: true, queued: true });
+    }
+  });
+
+  /**
+   * Clear All Pending Requests
+   * Service worker restart olduğunda in-flight pending request'leri temizler.
+   * SW terminate → restart döngüsünde server tarafında asılı kalan request'lerin deadlock'unu önler.
+   */
+  app.post('/api/clear-all-requests', (req, res) => {
+    // Sadece content-script üzerinden işlenen request'leri temizle.
+    // export_session ve get_tabs SW içinde işlendiğinden SW restart'ta silinmemeli —
+    // aksi hâlde MCP tool request gönderirken SW yeni session açıp hepsini siliyordu (race condition).
+    extensionData.jsExecutionRequest = null;
+    extensionData.actionExecutionRequest = null;
+    extensionData.captureScreenshotRequest = null;
+    extensionData.rawNetworkRequests = [];
+    extensionData.analyzePageRequests = [];
+    extensionData.selectElementRequest = null;
+    res.json({ success: true, cleared: true });
+  });
+
+  /**
+   * Auth token capture: SW → MCP server → execute_js
+   */
+  app.post('/api/capture-token', (req, res) => {
+    const { domain, token } = req.body || {};
+    if (domain && token) {
+      capturedAuthTokens[domain] = token;
+    }
+    res.json({ success: true });
+  });
+
+  app.get('/api/capture-token', (req, res) => {
+    const domain = req.query.domain;
+    if (domain) {
+      res.json({ token: capturedAuthTokens[domain] || null });
+    } else {
+      res.json({ tokens: capturedAuthTokens });
+    }
+  });
+
+  /**
+   * Insight stats: execute_js disambiguation fırsatları vs save_site_profile çağrıları
+   * /stop skill bu endpoint'i kontrol eder
+   */
+  app.get('/api/insight-stats', (req, res) => {
+    const opportunities = extensionData.insightOpportunities || {};
+    const saves = extensionData.profileSaves || {};
+    const unsaved = Object.keys(opportunities).filter(
+      domain => !saves[domain] || saves[domain] === 0
+    );
+    res.json({
+      opportunities,
+      saves,
+      unsaved,
+      hasUnsaved: unsaved.length > 0
+    });
+  });
+
+  /**
+   * Background execute_js auto-capture endpoint
+   * sandbox.html fetch interceptor'ından gelen API endpoint verilerini profile'a kaydeder.
+   */
+  app.post('/api/bg-capture', (req, res) => {
+    const { domain, url, method, status, contentType } = req.body || {};
+    if (!domain || !url) return res.json({ success: false, error: 'missing domain or url' });
+
+    try {
+      addCapturedEndpoint({
+        domain,
+        method: method || 'GET',
+        url,
+        status: status || null,
+        contentType: contentType || null
+      });
+      res.json({ success: true });
+    } catch (err) {
+      res.json({ success: false, error: err.message });
+    }
+  });
+
+  // ============================================================================
+  // Phase 2.3: Bridge Client GET Endpoints
+  // These endpoints allow the MCP thin client to read state and poll for results
+  // via HTTP instead of direct memory access.
+  // ============================================================================
+
+  /**
+   * GET /api/connection-status
+   * Returns connection state for the MCP thin client.
+   */
+  app.get('/api/connection-status', (req, res) => {
+    res.json({
+      isConnected: extensionData.isConnected,
+      activeTabUrl: extensionData.activeTabUrl || '',
+      lastUpdateTime: extensionData.lastUpdateTime,
+      pendingNavigation: extensionData.pendingNavigation || false,
+      currentSessionId: extensionData.currentSessionId || null,
+      sessionStartedAt: extensionData.sessionStartedAt || null
+    });
+  });
+
+  /**
+   * GET /api/selected-element
+   * Returns the currently selected element.
+   */
+  app.get('/api/selected-element', (req, res) => {
+    res.json({ element: extensionData.selectedElement || null });
+  });
+
+  /**
+   * GET /api/page-analysis
+   * Returns the current page analysis data.
+   */
+  app.get('/api/page-analysis', (req, res) => {
+    res.json({ analysis: extensionData.pageAnalysis || null });
+  });
+
+  /**
+   * GET /api/network-trace
+   * Returns the current network trace data.
+   */
+  app.get('/api/network-trace', (req, res) => {
+    res.json({ trace: extensionData.networkTrace || null });
+  });
+
+  /**
+   * GET /api/websocket-trace
+   * Returns the current WebSocket trace and connections data.
+   */
+  app.get('/api/websocket-trace', (req, res) => {
+    res.json({
+      trace: extensionData.websocketTrace || null,
+      connections: extensionData.websocketConnections || null
+    });
+  });
+
+  /**
+   * GET /api/state
+   * Returns all state fields for the MCP thin client.
+   * Includes request fields for validation (e.g. validateNoPendingExecution).
+   * Result fields are NOT included — use GET /api/result/:type for those.
+   */
+  app.get('/api/state', (req, res) => {
+    res.json({
+      // Connection & status
+      isConnected: extensionData.isConnected,
+      activeTabUrl: extensionData.activeTabUrl || '',
+      pendingNavigation: extensionData.pendingNavigation || false,
+      lastUpdateTime: extensionData.lastUpdateTime,
+      currentSessionId: extensionData.currentSessionId || null,
+      sessionStartedAt: extensionData.sessionStartedAt || null,
+      _connectionHealth: connectionHealth.getStatus(),
+
+      // Data fields
+      selectedElement: extensionData.selectedElement,
+      pageAnalysis: extensionData.pageAnalysis,
+      networkTrace: extensionData.networkTrace,
+      websocketTrace: extensionData.websocketTrace,
+      websocketConnections: extensionData.websocketConnections,
+      savedSelections: extensionData.savedSelections || [],
+      apiEndpoints: extensionData.apiEndpoints || [],  // NEW: for manage_site_profile save flow
+
+      // Request fields (for validation — e.g. check pending JS execution)
+      jsExecutionRequest: extensionData.jsExecutionRequest || null,
+      actionExecutionRequest: extensionData.actionExecutionRequest || null,
+      selectElementRequest: extensionData.selectElementRequest || null,
+      captureScreenshotRequest: extensionData.captureScreenshotRequest || null,
+      exportSessionRequest: extensionData.exportSessionRequest || null,
+      tabsRequest: extensionData.tabsRequest || null,
+      analyzePageRequests: extensionData.analyzePageRequests || [],
+      rawNetworkRequests: extensionData.rawNetworkRequests || [],
+
+      // Result fields (for validation — e.g. check stale result)
+      jsExecutionResult: extensionData.jsExecutionResult || null,
+      actionExecutionResult: extensionData.actionExecutionResult || null,
+      selectElementResult: extensionData.selectElementResult || null,
+      captureScreenshotResult: extensionData.captureScreenshotResult || null,
+      exportSessionResult: extensionData.exportSessionResult || null,
+      tabsResult: extensionData.tabsResult || null,
+      analyzePageResults: extensionData.analyzePageResults || {},
+      rawNetworkResults: extensionData.rawNetworkResults || {},
+
+      // Profile & insight tracking
+      insightOpportunities: extensionData.insightOpportunities || {},
+      profileSaves: extensionData.profileSaves || {},
+
+      // Restart signal — MCP server reads this to decide whether to exit
+      restartRequestedAt: extensionData.restartRequestedAt || null
+    });
+  });
+
+  /**
+   * GET /api/result/:type
+   * Returns and consumes (clears) a result by type. Used by the MCP thin client
+   * for result polling instead of direct memory access.
+   *
+   * Supported types:
+   *   js-execution, action-execution, select-element, capture-screenshot,
+   *   export-session, tabs, analyze-page, raw-network
+   *
+   * For analyze-page and raw-network, requestId query param is required.
+   * For single-result types, requestId is optional (matches against requestId/id).
+   */
+  app.get('/api/result/:type', (req, res) => {
+    const { type } = req.params;
+    const { requestId } = req.query;
+
+    // Single-result types: read, match, consume
+    const singleResultTypes = {
+      'action-execution': { field: 'actionExecutionResult', clear: () => { extensionData.actionExecutionResult = null; } },
+      'select-element': { field: 'selectElementResult', clear: () => { extensionData.selectElementResult = null; } },
+      'capture-screenshot': { field: 'captureScreenshotResult', clear: () => { extensionData.captureScreenshotResult = null; } },
+      'export-session': { field: 'exportSessionResult', clear: () => { extensionData.exportSessionResult = null; } },
+      'tabs': { field: 'tabsResult', clear: () => { extensionData.tabsResult = null; } },
+    };
+
+    // Map-result types: read by requestId, delete entry, consume
+    const mapResultTypes = {
+      'js-execution': 'jsExecutionResults',
+      'analyze-page': 'analyzePageResults',
+      'raw-network': 'rawNetworkResults',
+    };
+
+    if (singleResultTypes[type]) {
+      const { field, clear } = singleResultTypes[type];
+      const result = extensionData[field];
+
+      if (!result) {
+        return res.json({ found: false });
+      }
+
+      // Match by requestId if provided
+      if (requestId && result.requestId !== requestId && result.id !== requestId) {
+        return res.json({ found: false });
+      }
+
+      // Consume (clear) the result
+      clear();
+      res.json({ found: true, result });
+    } else if (mapResultTypes[type]) {
+      const mapField = mapResultTypes[type];
+
+      if (!requestId || !extensionData[mapField][requestId]) {
+        return res.json({ found: false });
+      }
+
+      const result = extensionData[mapField][requestId];
+      delete extensionData[mapField][requestId]; // consume
+      res.json({ found: true, result });
+    } else {
+      res.status(400).json({ error: `Unknown result type: ${type}` });
+    }
+  });
+
+  /**
+   * POST /api/metrics — Extension-side event reporting
+   * Accepts connection events from the extension (heartbeat failures, sync failures, etc.)
+   */
+  app.post('/api/metrics', (req, res) => {
+    const { event_type, duration_ms, retry_count, failure_reason, metadata } = req.body;
+
+    if (!event_type) {
+      return res.status(400).json({ success: false, error: 'event_type is required' });
+    }
+
+    metricsDB.recordConnectionEvent({
+      timestamp: new Date().toISOString(),
+      event_type,
+      duration_ms: duration_ms || null,
+      retry_count: retry_count || null,
+      failure_reason: failure_reason || null,
+      metadata: metadata ? (typeof metadata === 'string' ? metadata : JSON.stringify(metadata)) : null,
+    });
+
+    res.json({ success: true });
+  });
+
+  /**
+   * POST /api/restart — Restart bridge daemon + signal MCP server to restart
+   * Extension popup uses this to restart bridge with new code.
+   * Flow: set restart signal → persist state → spawn new process → shutdown current process
+   * MCP server detects restartRequestedAt via /api/state and exits with process.exit(0),
+   * which causes Claude Code to restart it with fresh code.
+   */
+  app.post('/api/restart', (req, res) => {
+    const origin = req.get('Origin') || req.get('Referer') || '';
+    if (origin && !/^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?/.test(origin) && !/^chrome-extension:\/\//.test(origin)) {
+      return res.status(403).json({ success: false, error: 'Forbidden' });
+    }
+
+    // Signal MCP server to restart (set before persist so it survives bridge restart)
+    extensionData.restartRequestedAt = Date.now();
+
+    res.json({ success: true, message: 'Restarting bridge and MCP server...', restartRequestedAt: extensionData.restartRequestedAt });
+
+    // Persist state before restart (now includes restartRequestedAt)
+    try {
+      persistStateNow(extensionData);
+      console.error('[MCP Bridge] 📝 State persisted before restart');
+    } catch (err) {
+      console.error('[MCP Bridge] ⚠️ Failed to persist state before restart:', err.message);
+    }
+
+    // Record restart event in metrics
+    metricsDB.recordConnectionEvent({
+      event_type: 'bridge_spawn',
+      failure_reason: 'restart',
+      metadata: JSON.stringify({ port: httpPort, pid: process.pid, restarted: true }),
+    });
+
+    // Spawn new bridge daemon process
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    const bridgePath = join(currentDir, '..', 'bridge-daemon.js');
+
+    console.error('[MCP Bridge] 🔄 Spawning new bridge daemon...');
+    const newProcess = spawn('node', [bridgePath], {
+      detached: true,
+      stdio: 'ignore',
+      env: { ...process.env, MCP_PORT: String(httpPort) },
+    });
+    newProcess.unref();
+
+    // Shutdown current process after short delay
+    setTimeout(() => {
+      console.error('[MCP Bridge] 🛑 Current process shutting down for restart...');
+      process.exit(0);
+    }, 300);
+  });
+
+  /**
+   * Kill Endpoint: Yeni sunucu başladığında port konfliktini çözmek için eski sunucuyu kapatır.
+   * /api/die is a kill, not a coordinated restart — clear the restart signal.
+   */
+  app.post('/api/die', (req, res) => {
+    const origin = req.get('Origin') || req.get('Referer') || '';
+    if (origin && !/^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?/.test(origin) && !/^chrome-extension:\/\//.test(origin)) {
+      return res.status(403).json({ success: false, error: 'Forbidden' });
+    }
+
+    // Clear restart signal — /api/die is a kill, not a coordinated restart
+    extensionData.restartRequestedAt = null;
+
+    res.json({ success: true, message: 'Shutting down...' });
+
+    // Phase 1.3: Persist state before exit to survive restart
+    try {
+      persistStateNow(extensionData);
+      console.error('[MCP Bridge] 📝 State persisted before termination');
+    } catch (err) {
+      console.error('[MCP Bridge] ⚠️ Failed to persist state before termination:', err.message);
+    }
+
+    setTimeout(() => {
+      console.error('[MCP Bridge] 🛑 Received termination request (/api/die). Exiting...');
+      process.exit(0);
+    }, 200); // 100ms → 200ms to allow persist to complete
+  });
+
+  /**
+   * POST /api/clear-restart-signal — Clear the restart signal after MCP server has restarted.
+   * Called by the fresh MCP server instance after detecting restartRequestedAt in /api/state.
+   */
+  app.post('/api/clear-restart-signal', (req, res) => {
+    extensionData.restartRequestedAt = null;
+    res.json({ success: true });
+  });
+};