@yusufffararatt/dombridge-mcp 2.7.5

package/src/profiles/profile-repo.js

@@ -0,0 +1,183 @@
+/**
+ * ProfileRepo — domain operations on top of ProfileDB.
+ * Handles BUG #1 fix (hostname filter) and BUG #2 fix (real endpoint persistence).
+ */
+import { ProfileDB } from './profile-db.js';
+import { logger } from '../utils/logger.js';
+
+function hostnameOf(url) {
+    try {
+        return new URL(url).hostname.toLowerCase();
+    } catch {
+        return null;
+    }
+}
+
+function isAllowedHostname(host, domain) {
+    if (!host || !domain) return false;
+    const d = domain.toLowerCase();
+    // Exact match OR subdomain match
+    if (host === d || host.endsWith('.' + d)) return true;
+    // Bug #6 fix: also accept sibling subdomains that share the same root
+    // (e.g. profile='www.trendyol.com' accepts 'apigw.trendyol.com' since both share 'trendyol.com' root)
+    const getRootDomain = (h) => {
+        const parts = h.split('.');
+        if (parts.length < 2) return h;
+        // last 2 parts = root (handles .com, .co.uk via simple heuristic)
+        return parts.slice(-2).join('.');
+    };
+    return getRootDomain(host) === getRootDomain(d);
+}
+
+export class ProfileRepo {
+    constructor(dbPath) {
+        this.db = new ProfileDB(dbPath);
+    }
+
+    close() {
+        this.db.close();
+    }
+
+    // ── save (with BUG #1 hostname filter) ───────────────────────────
+    save(domain, { endpoints = [], notes, framework, pageType } = {}) {
+        const dropped = [];
+        let inserted = 0;
+
+        // BUG #2 fix: actually persist endpoints, not just notes
+        this.db.upsertProfile({ domain, framework, pageType, notes });
+
+        for (const ep of endpoints) {
+            if (!ep || !ep.url) continue;
+            const host = hostnameOf(ep.url);
+            if (!isAllowedHostname(host, domain)) {
+                dropped.push({ url: ep.url, reason: `host=${host} != domain=${domain}` });
+                logger.warn(`[profile] dropped ${ep.url} (host=${host} != domain=${domain})`);
+                continue;
+            }
+            this.db.upsertEndpoint(domain, ep);
+            inserted++;
+        }
+
+        return { inserted, dropped };
+    }
+
+    // ── load ─────────────────────────────────────────────────────────
+    load(domain) {
+        const profile = this.db.getProfile(domain);
+        if (!profile) return null;
+
+        const endpoints = this.db.db.prepare(`
+            SELECT method, url, status, content_type AS contentType,
+                   first_seen_at AS firstSeenAt, last_seen_at AS lastSeenAt, hit_count AS hitCount
+            FROM endpoints WHERE domain = ? ORDER BY last_seen_at DESC
+        `).all(domain);
+
+        const paths = this.db.db.prepare(`
+            SELECT path, source_key AS sourceKey, example_value AS exampleValue
+            FROM paths WHERE domain = ?
+        `).all(domain);
+
+        return {
+            domain: profile.domain,
+            framework: profile.framework,
+            pageType: profile.page_type,
+            notes: profile.notes,
+            version: profile.version,
+            firstSeenAt: profile.first_seen_at,
+            lastSeenAt: profile.last_seen_at,
+            endpoints,
+            paths
+        };
+    }
+
+    // ── list ─────────────────────────────────────────────────────────
+    list({ limit = 20 } = {}) {
+        const rows = this.db.db.prepare(`
+            SELECT p.domain, p.framework, p.last_seen_at AS lastSeenAt,
+                   (SELECT COUNT(*) FROM endpoints e WHERE e.domain = p.domain) AS endpointCount,
+                   (SELECT COUNT(*) FROM paths pa WHERE pa.domain = p.domain) AS pathCount
+            FROM site_profiles p
+            ORDER BY p.last_seen_at DESC
+            LIMIT ?
+        `).all(limit);
+        return rows;
+    }
+
+    // ── delete ───────────────────────────────────────────────────────
+    delete(domain) {
+        const existing = this.db.getProfile(domain);
+        if (!existing) return { deleted: false };
+        this.db.deleteProfile(domain);
+        return { deleted: true };
+    }
+
+    // ── update (partial patch) ───────────────────────────────────────
+    update(domain, patch) {
+        const existing = this.db.getProfile(domain);
+        if (!existing) return { updated: false };
+
+        const sets = [];
+        const args = [];
+        if (patch.notes !== undefined) { sets.push('notes = ?'); args.push(patch.notes); }
+        if (patch.framework !== undefined) { sets.push('framework = ?'); args.push(patch.framework); }
+        if (patch.pageType !== undefined) { sets.push('page_type = ?'); args.push(patch.pageType); }
+        if (patch.stableSelectorsJson !== undefined) { sets.push('stable_selectors_json = ?'); args.push(patch.stableSelectorsJson); }
+        if (patch.authInfoJson !== undefined) { sets.push('auth_info_json = ?'); args.push(patch.authInfoJson); }
+        sets.push('last_seen_at = ?'); args.push(Date.now());
+        sets.push('version = version + 1');
+        args.push(domain);
+
+        this.db.db.prepare(
+            `UPDATE site_profiles SET ${sets.join(', ')} WHERE domain = ?`
+        ).run(...args);
+
+        // Bug #7 fix: support incremental endpoint upsert via update() call
+        let endpointsInserted = 0;
+        if (Array.isArray(patch.endpoints) && patch.endpoints.length > 0) {
+            for (const ep of patch.endpoints) {
+                if (!ep || !ep.url) continue;
+                this.db.upsertEndpoint(domain, ep);
+                endpointsInserted++;
+            }
+        }
+
+        return { updated: true, endpointsInserted };
+    }
+
+    // ── check (drift detection) ──────────────────────────────────────
+    check(domain, liveCapture = []) {
+        const loaded = this.load(domain);
+        if (!loaded) return { error: 'profile_not_found', domain };
+
+        const knownKeys = new Set(loaded.endpoints.map(e => `${e.method}:${hostnameOf(e.url)}${new URL(e.url).pathname}`));
+        const liveKeys = new Set();
+
+        const newEndpoints = [];
+        for (const ep of liveCapture) {
+            if (!ep?.url) continue;
+            const key = `${(ep.method || 'GET').toUpperCase()}:${hostnameOf(ep.url)}${(new URL(ep.url).pathname)}`;
+            liveKeys.add(key);
+            if (!knownKeys.has(key)) {
+                newEndpoints.push({ url: ep.url, method: ep.method, status: ep.status });
+            }
+        }
+
+        const missing = loaded.endpoints
+            .filter(e => !liveKeys.has(`${e.method}:${hostnameOf(e.url)}${new URL(e.url).pathname}`))
+            .map(e => ({ url: e.url, method: e.method, status: e.status, lastSeenAt: e.lastSeenAt }));
+
+        return {
+            domain,
+            knownEndpointCount: loaded.endpoints.length,
+            newCount: newEndpoints.length,
+            missingCount: missing.length,
+            new: newEndpoints,
+            missing
+        };
+    }
+
+    // ── upsertPath (exposed for extract-data flow) ───────────────────
+    upsertPath(domain, { path, sourceKey, exampleValue }) {
+        this.db.upsertPath(domain, { path, sourceKey, exampleValue });
+    }
+}

package/src/state/bridge-client.js

@@ -0,0 +1,272 @@
+/**
+ * Bridge Client — HTTP client for bridge daemon communication
+ *
+ * Phase 2.3: MCP thin client uses this instead of direct extensionData access.
+ * All state reads go through HTTP GET endpoints.
+ * All request/result operations go through HTTP POST/GET endpoints.
+ *
+ * Architecture:
+ *   MCP Client (index.js) ←→ BridgeClient ←→ Bridge Daemon (bridge-daemon.js)
+ *                                                ↕
+ *                                           Extension (Chrome)
+ *
+ * Property getters mirror extensionData fields for drop-in replacement in tool handlers.
+ * State is cached from /api/state and refreshed before each tool call.
+ */
+
+const DEFAULT_PORT = 3101;
+const DEFAULT_POLL_INTERVAL = 300;
+const DEFAULT_REQUEST_TIMEOUT = 10000;
+const FETCH_TIMEOUT = 5000;
+
+export class BridgeClient {
+  constructor(port = DEFAULT_PORT) {
+    this.port = port;
+    this.baseUrl = `http://localhost:${port}`;
+    this._state = {};
+  }
+
+  // ============================================================================
+  // State refresh — fetch all state from bridge daemon
+  // ============================================================================
+
+  /**
+   * Refresh cached state from bridge daemon.
+   * Called before each tool invocation so that tool handlers
+   * can access fresh state via synchronous property getters.
+   */
+  async refreshState() {
+    try {
+      const res = await this._fetch('/api/state');
+      this._state = await res.json();
+    } catch (err) {
+      throw new Error(`Bridge not available at ${this.baseUrl}: ${err.message}`);
+    }
+    return this._state;
+  }
+
+  // ============================================================================
+  // Synchronous property access (from cached state)
+  // These mirror extensionData properties for drop-in replacement.
+  // ============================================================================
+
+  // Connection & status
+  get isConnected() { return this._state.isConnected || false; }
+  get activeTabUrl() { return this._state.activeTabUrl || ''; }
+  get pendingNavigation() { return this._state.pendingNavigation || false; }
+  get lastUpdateTime() { return this._state.lastUpdateTime || null; }
+  get currentSessionId() { return this._state.currentSessionId || null; }
+  get sessionStartedAt() { return this._state.sessionStartedAt || null; }
+  get _connectionHealth() { return this._state._connectionHealth || null; }
+
+  // Data fields
+  get selectedElement() { return this._state.selectedElement || null; }
+  get pageAnalysis() { return this._state.pageAnalysis || null; }
+  get networkTrace() { return this._state.networkTrace || null; }
+  get websocketTrace() { return this._state.websocketTrace || null; }
+  get websocketConnections() { return this._state.websocketConnections || null; }
+  get savedSelections() { return this._state.savedSelections || []; }
+
+  // Request fields (for validation — e.g. validateNoPendingExecution)
+  get jsExecutionRequest() { return this._state.jsExecutionRequest || null; }
+  get jsExecutionResult() { return this._state.jsExecutionResult || null; }
+  get actionExecutionRequest() { return this._state.actionExecutionRequest || null; }
+  get actionExecutionResult() { return this._state.actionExecutionResult || null; }
+  get selectElementRequest() { return this._state.selectElementRequest || null; }
+  get selectElementResult() { return this._state.selectElementResult || null; }
+  get captureScreenshotRequest() { return this._state.captureScreenshotRequest || null; }
+  get captureScreenshotResult() { return this._state.captureScreenshotResult || null; }
+  get exportSessionRequest() { return this._state.exportSessionRequest || null; }
+  get exportSessionResult() { return this._state.exportSessionResult || null; }
+  get tabsRequest() { return this._state.tabsRequest || null; }
+  get tabsResult() { return this._state.tabsResult || null; }
+  get analyzePageRequests() { return this._state.analyzePageRequests || []; }
+  get analyzePageResults() { return this._state.analyzePageResults || {}; }
+  get rawNetworkRequests() { return this._state.rawNetworkRequests || []; }
+  get rawNetworkResults() { return this._state.rawNetworkResults || {}; }
+
+  // Profile & insight tracking
+  get insightOpportunities() { return this._state.insightOpportunities || {}; }
+  get profileSaves() { return this._state.profileSaves || {}; }
+
+  // Captured API endpoints from discover_apis (NEW — for manage_site_profile save flow)
+  get apiEndpoints() { return this._state.apiEndpoints || []; }
+  getCapturedEndpoints(domain) {
+    if (!domain) return this._state.apiEndpoints || [];
+    return (this._state.apiEndpoints || []).filter((e) => e.domain === domain);
+  }
+
+  /**
+   * Push a captured endpoint to the bridge daemon's in-memory state.
+   * Bridge dedupes by (domain, method, url). Fire-and-forget; failure
+   * does not break the calling tool.
+   *
+   * Returns the inserted entry so callers can update their local cache.
+   */
+  async addCapturedEndpoint(domain, endpoint) {
+    if (!domain || !endpoint || !endpoint.url) return null;
+    const res = await this.post('captured-endpoint', { domain, ...endpoint });
+    // Optimistically reflect the new entry in our local cache so a
+    // subsequent getCapturedEndpoints() within the same process call
+    // (e.g. manage_site_profile after discover_apis) sees it without
+    // requiring a full refreshState() round-trip.
+    if (res && res.entry) {
+      const list = this._state.apiEndpoints || (this._state.apiEndpoints = []);
+      const key = `${domain}::${(endpoint.method || 'GET').toUpperCase()}::${endpoint.url}`;
+      const idx = list.findIndex(
+        (e) => `${e.domain}::${(e.method || 'GET').toUpperCase()}::${e.url}` === key
+      );
+      if (idx >= 0) list[idx] = res.entry;
+      else list.push(res.entry);
+    }
+    return res;
+  }
+
+  // Restart signal — MCP server checks this to decide whether to exit
+  get restartRequestedAt() { return this._state.restartRequestedAt || null; }
+
+  // ============================================================================
+  // Write operations — forward to bridge daemon via HTTP POST
+  // ============================================================================
+
+  /**
+   * Update insight opportunities (increments counter for domain).
+   * Replaces: extensionData.insightOpportunities[domain]++
+   */
+  async incrementInsight(domain) {
+    // Read current value, increment, write back
+    const current = this._state.insightOpportunities?.[domain] || 0;
+    this._state.insightOpportunities = {
+      ...(this._state.insightOpportunities || {}),
+      [domain]: current + 1
+    };
+    // Persist to bridge daemon via heartbeat or sync
+    // Note: insight tracking is best-effort; no dedicated endpoint needed
+  }
+
+  // ============================================================================
+  // Async state access methods (fresh data per call)
+  // ============================================================================
+
+  async getConnectionStatus() {
+    const res = await this._fetch('/api/connection-status');
+    return res.json();
+  }
+
+  async getSelectedElement() {
+    const res = await this._fetch('/api/selected-element');
+    return res.json();
+  }
+
+  async getPageAnalysis() {
+    const res = await this._fetch('/api/page-analysis');
+    return res.json();
+  }
+
+  async getNetworkTrace() {
+    const res = await this._fetch('/api/network-trace');
+    return res.json();
+  }
+
+  async getWebSocketTrace() {
+    const res = await this._fetch('/api/websocket-trace');
+    return res.json();
+  }
+
+  // ============================================================================
+  // Request queuing (POST to existing bridge routes)
+  // ============================================================================
+
+  /**
+   * Queue a request to the bridge daemon via HTTP POST.
+   * @param {string} endpoint - Route name (e.g. 'execute-js', 'select-element')
+   * @param {object} data - Request payload
+   * @returns {Promise<object>} Response from bridge
+   */
+  async queueRequest(endpoint, data) {
+    const res = await this._fetch(`/api/${endpoint}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data)
+    });
+    return res.json();
+  }
+
+  // ============================================================================
+  // Result polling (GET /api/result/:type)
+  // ============================================================================
+
+  /**
+   * Poll for a result from the bridge daemon.
+   * Uses spin-wait with configurable interval and timeout.
+   * The result is consumed (cleared) on the bridge daemon side on read.
+   *
+   * @param {string} type - Result type (e.g. 'js-execution', 'select-element')
+   * @param {string} requestId - Request ID to match
+   * @param {number} timeoutMs - Maximum wait time in ms
+   * @param {number} intervalMs - Polling interval in ms
+   * @returns {Promise<object|null>} Result data or null on timeout
+   */
+  async waitForResult(type, requestId, timeoutMs = DEFAULT_REQUEST_TIMEOUT, intervalMs = DEFAULT_POLL_INTERVAL) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      try {
+        const res = await this._fetch(`/api/result/${type}?requestId=${encodeURIComponent(requestId)}`);
+        const data = await res.json();
+        if (data.found) {
+          return data.result;
+        }
+      } catch {
+        // Bridge might be temporarily unavailable, retry
+      }
+      await new Promise(resolve => setTimeout(resolve, intervalMs));
+    }
+    return null; // Timeout
+  }
+
+  // ============================================================================
+  // Health check
+  // ============================================================================
+
+  async health() {
+    const res = await this._fetch('/health');
+    return res.json();
+  }
+
+  // ============================================================================
+  // Control signals — simple POST to bridge daemon
+  // ============================================================================
+
+  /**
+   * Send a simple POST to a bridge daemon endpoint.
+   * Used for control signals (e.g. clearing restart flag).
+   * @param {string} endpoint - Route path (e.g. 'clear-restart-signal')
+   * @returns {Promise<object>} Response from bridge
+   */
+  async post(endpoint, data = {}) {
+    const res = await this._fetch(`/api/${endpoint}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data)
+    });
+    return res.json();
+  }
+
+  // ============================================================================
+  // Internal helper
+  // ============================================================================
+
+  async _fetch(path, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+    try {
+      const response = await fetch(url, { ...options, signal: controller.signal });
+      clearTimeout(timeout);
+      return response;
+    } catch (err) {
+      clearTimeout(timeout);
+      throw err;
+    }
+  }
+}

package/src/state/bridge-persistence.js

@@ -0,0 +1,205 @@
+/**
+ * Bridge State Persistence
+ *
+ * Persists extensionData to disk as JSON with atomic writes.
+ * - Debounced writes (2s interval) to avoid excessive disk I/O
+ * - Atomic write: tmp file → rename (no partial/corrupt states)
+ * - Immediate writes for graceful shutdown
+ * - Startup load to restore state after process restart
+ *
+ * Phase 1.1 of Persistent Bridge Architecture.
+ */
+
+import { writeFileSync, readFileSync, renameSync, unlinkSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Go up from src/state/ → project root → mcp-server/state/
+const STATE_DIR = join(__dirname, '..', '..', 'state');
+const STATE_FILE = join(STATE_DIR, 'bridge-state.json');
+const TMP_FILE = join(STATE_DIR, 'bridge-state.tmp.json');
+
+// Debounce state
+let persistTimer = null;
+const DEBOUNCE_MS = 2000;
+
+// Fields to exclude from persistence (request queues are transient)
+const EXCLUDED_FIELDS = new Set([
+  'jsExecutionRequest',
+  'jsExecutionResult',
+  'jsExecutionResults',
+  'actionExecutionRequest',
+  'actionExecutionResult',
+  'captureScreenshotRequest',
+  'captureScreenshotResult',
+  'rawNetworkRequests',
+  'rawNetworkResults',
+  'analyzePageRequests',
+  'analyzePageResults',
+  'selectElementRequest',
+  'selectElementResult',
+  'exportSessionRequest',
+  'exportSessionResult',
+  'tabsRequest',
+  'tabsResult',
+  'pendingNavigation',
+  'isConnected',
+  'lastUpdateTime',
+  '_connectionHealth',
+  'insightOpportunities',
+  'profileSaves',
+]);
+
+/**
+ * Ensure state directory exists
+ */
+function ensureStateDir() {
+  if (!existsSync(STATE_DIR)) {
+    mkdirSync(STATE_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Serialize extensionData, excluding transient fields
+ * @param {object} extensionData - The shared state object
+ * @returns {object} Serializable subset
+ */
+function serializeState(extensionData) {
+  const snapshot = {};
+  for (const key of Object.keys(extensionData)) {
+    if (EXCLUDED_FIELDS.has(key)) continue;
+    const value = extensionData[key];
+    // Skip null/undefined — they'll be defaults on load
+    if (value === null || value === undefined) continue;
+    // Skip empty arrays/objects — no value in persisting
+    if (Array.isArray(value) && value.length === 0) continue;
+    if (typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0) continue;
+    snapshot[key] = value;
+  }
+  return snapshot;
+}
+
+/**
+ * Atomic write: write to tmp file, then rename over target.
+ * Prevents corrupt state from partial writes.
+ * @param {object} data - The data to write
+ */
+function atomicWrite(data) {
+  ensureStateDir();
+  const json = JSON.stringify(data, null, 2);
+  try {
+    writeFileSync(TMP_FILE, json, 'utf8');
+    renameSync(TMP_FILE, STATE_FILE);
+  } catch (err) {
+    // Clean up tmp file if rename fails
+    try { unlinkSync(TMP_FILE); } catch { /* ignore */ }
+    throw err;
+  }
+}
+
+/**
+ * Persist extensionData to disk (debounced).
+ * Called after every state mutation. Will write at most once every DEBOUNCE_MS.
+ * @param {object} extensionData - The shared state object
+ */
+export function schedulePersist(extensionData) {
+  // Cancel any pending write
+  if (persistTimer) {
+    clearTimeout(persistTimer);
+  }
+
+  persistTimer = setTimeout(() => {
+    try {
+      const data = serializeState(extensionData);
+      atomicWrite(data);
+    } catch (err) {
+      console.error('[Bridge Persistence] Debounced write failed:', err.message);
+    }
+    persistTimer = null;
+  }, DEBOUNCE_MS);
+}
+
+/**
+ * Persist extensionData to disk IMMEDIATELY (no debounce).
+ * Used for graceful shutdown and /api/die handler.
+ * @param {object} extensionData - The shared state object
+ */
+export function persistStateNow(extensionData) {
+  // Cancel any pending debounced write
+  if (persistTimer) {
+    clearTimeout(persistTimer);
+    persistTimer = null;
+  }
+
+  try {
+    const data = serializeState(extensionData);
+    atomicWrite(data);
+  } catch (err) {
+    console.error('[Bridge Persistence] Immediate write failed:', err.message);
+    throw err;
+  }
+}
+
+/**
+ * Load persisted state from disk.
+ * Merges into the provided extensionData object, preserving defaults
+ * for any missing fields.
+ * @param {object} extensionData - The shared state object to merge into
+ * @returns {boolean} True if state was loaded, false if no file or error
+ */
+export function loadPersistedState(extensionData) {
+  if (!existsSync(STATE_FILE)) {
+    return false;
+  }
+
+  try {
+    const raw = readFileSync(STATE_FILE, 'utf8');
+    const persisted = JSON.parse(raw);
+
+    // Merge persisted data into extensionData (deep merge for nested objects)
+    for (const [key, value] of Object.entries(persisted)) {
+      if (EXCLUDED_FIELDS.has(key)) continue; // Skip transient fields
+      if (!(key in extensionData)) continue;  // Skip unknown fields
+
+      if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        // Deep merge for objects (networkTrace, websocketTrace, pageAnalysis, etc.)
+        if (typeof extensionData[key] === 'object' && extensionData[key] !== null && !Array.isArray(extensionData[key])) {
+          Object.assign(extensionData[key], value);
+        } else {
+          extensionData[key] = value;
+        }
+      } else {
+        extensionData[key] = value;
+      }
+    }
+
+    console.error(`[Bridge Persistence] Loaded state from disk (${Object.keys(persisted).length} fields)`);
+    return true;
+  } catch (err) {
+    console.error('[Bridge Persistence] Failed to load state:', err.message);
+    // Don't throw — start with empty state rather than crash
+    return false;
+  }
+}
+
+/**
+ * Clear persisted state file.
+ * Used for testing or when state is intentionally reset.
+ */
+export function clearPersistedState() {
+  try {
+    if (existsSync(STATE_FILE)) unlinkSync(STATE_FILE);
+    if (existsSync(TMP_FILE)) unlinkSync(TMP_FILE);
+  } catch (err) {
+    console.error('[Bridge Persistence] Failed to clear state:', err.message);
+  }
+}
+
+/**
+ * Get the state file path (for external checks)
+ * @returns {string}
+ */
+export function getStateFilePath() {
+  return STATE_FILE;
+}

package/src/state/cache.js

@@ -0,0 +1,38 @@
+/**
+ * Temporary Data Caching
+ * Geçici veri önbellekleme (gelecekte genişletilebilir)
+ */
+
+const cache = new Map();
+
+export const setCache = (key, value, ttlMs = 60000) => {
+  const expiresAt = Date.now() + ttlMs;
+  cache.set(key, { value, expiresAt });
+};
+
+export const getCache = (key) => {
+  const item = cache.get(key);
+
+  if (!item) {
+    return null;
+  }
+
+  if (Date.now() > item.expiresAt) {
+    cache.delete(key);
+    return null;
+  }
+
+  return item.value;
+};
+
+export const deleteCache = (key) => {
+  cache.delete(key);
+};
+
+export const clearCache = () => {
+  cache.clear();
+};
+
+export const getCacheSize = () => {
+  return cache.size;
+};