crawlforge-mcp-server 3.0.18 → 3.3.1

package/src/core/ActionExecutor.js

@@ -171,49 +171,8 @@ export class ActionExecutor extends EventEmitter {
         actualChainConfig = chainConfig;
       }
 
-      // For testing purposes, provide mock execution for example.com
-      if (url === 'http://example.com') {
-        const actions = Array.isArray(chainConfig) ? chainConfig : actualChainConfig.actions;
-        const mockResults = actions.map((action, index) => {
-          const baseResult = {
-            id: `mock_action_${index}`,
-            type: action.type,
-            success: true,
-            executionTime: 10,
-            timestamp: Date.now(),
-            description: `Mock ${action.type} action`
-          };
-
-          if (action.type === 'wait') {
-            const waitTime = action.duration || action.milliseconds || 100;
-            baseResult.result = { waited: waitTime };
-          } else if (action.type === 'click') {
-            baseResult.result = { selector: action.selector, button: 'left' };
-          } else {
-            baseResult.result = { mockResult: true };
-          }
-
-          return baseResult;
-        });
-
-        return {
-          success: true,
-          chainId,
-          url,
-          executionTime: Date.now() - startTime,
-          results: mockResults,
-          screenshots: [],
-          metadata: {
-            userAgent: 'mock-agent',
-            viewport: { width: 1280, height: 720 }
-          },
-          stats: {
-            totalActions: mockResults.length,
-            successfulActions: mockResults.filter(r => r.success).length,
-            failedActions: mockResults.filter(r => !r.success).length
-          }
-        };
-      }
+      // (v3.0.19 cleanup) The legacy example.com mock branch was removed — no
+      // test depended on it and it short-circuited real validation. See §A3.
 
       // Validate chain configuration
       const validatedChain = ActionChainSchema.parse(actualChainConfig);

package/src/core/AuthManager.js

@@ -6,8 +6,10 @@
 // Using native fetch (Node.js 18+)
 import fs from 'fs/promises';
 import path from 'path';
+import { randomUUID } from 'crypto';
 import { isCreatorModeVerified } from './creatorMode.js';
 import { resolveApiEndpoint } from './endpointGuard.js';
+import { logger } from '../utils/Logger.js';
 
 class AuthManager {
   constructor() {
@@ -33,17 +35,23 @@ class AuthManager {
 
   /**
    * Initialize the auth manager and load stored config
+   *
+   * Audit phase 5: re-validate the stored API key against the backend at startup.
+   * If the backend explicitly reports the key as revoked/invalid, we throw —
+   * the server must refuse to start rather than silently run with a dead key.
+   * Network failures are tolerated (we already have a cached config and the
+   * fail-closed credit check from audit phase 2 handles runtime revocation).
    */
   async initialize() {
     if (this.initialized) return;
-    
+
     // Skip config loading in creator mode
     if (this.isCreatorMode()) {
       console.log('🚀 Creator Mode Active - Unlimited Access Enabled');
       this.initialized = true;
       return;
     }
-    
+
     try {
       await this.loadConfig();
       this.initialized = true;
@@ -52,6 +60,39 @@ class AuthManager {
       this.initialized = true;
     }
 
+    // Phase 5: re-validate cached API key with backend. Refuse to start if revoked.
+    if (this.config?.apiKey && process.env.CRAWLFORGE_SKIP_STARTUP_VALIDATION !== 'true') {
+      const validation = await this.validateApiKey(this.config.apiKey);
+      if (!validation.valid) {
+        const lower = (validation.error || '').toLowerCase();
+        const isExplicitReject =
+          lower.includes('invalid') ||
+          lower.includes('revoked') ||
+          lower.includes('not found') ||
+          lower.includes('expired') ||
+          lower.includes('unauthorized');
+        if (isExplicitReject) {
+          const rejectErr = new Error(
+            `CrawlForge API key rejected by backend at startup: ${validation.error}. ` +
+            `Run \`npm run setup\` with a current key, or set CRAWLFORGE_SKIP_STARTUP_VALIDATION=true to bypass.`
+          );
+          logger.error('Startup API key validation rejected by backend', rejectErr, {
+            backendError: validation.error
+          });
+          throw rejectErr;
+        }
+        // Connection error — tolerate, log, continue. Runtime credit check will fail closed.
+        logger.warn('Startup API key validation skipped (backend unreachable)', {
+          error: validation.error
+        });
+      } else {
+        logger.info('Startup API key validation OK', {
+          userId: validation.userId,
+          creditsRemaining: validation.creditsRemaining
+        });
+      }
+    }
+
     try {
       await this._flushPendingUsage();
     } catch {
@@ -236,6 +277,11 @@ class AuthManager {
       this.creditCache.set(userId, Math.max(0, cached - creditsUsed));
     }
 
+    // Audit phase A2: every usage report gets a request ID and idempotency key
+    // so retries (in-memory or via pending-usage.json) are safe to replay.
+    const requestId = randomUUID();
+    const idempotencyKey = randomUUID();
+
     const payload = {
       tool,
       creditsUsed,
@@ -243,6 +289,8 @@ class AuthManager {
       responseStatus,
       processingTime,
       timestamp: new Date().toISOString(),
+      requestId,
+      idempotencyKey,
       version: '3.0.3'
     };
 
@@ -251,7 +299,8 @@ class AuthManager {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
-          'X-API-Key': this.config.apiKey
+          'X-API-Key': this.config.apiKey,
+          'Idempotency-Key': idempotencyKey
         },
         body: JSON.stringify(payload),
         signal: AbortSignal.timeout(5000)
@@ -260,8 +309,20 @@ class AuthManager {
       await this._flushPendingUsage();
     } catch (error) {
       // Log but don't throw - usage reporting should not break tool execution
-      console.error('Failed to report usage:', error.message);
-      await this._appendPendingUsage({ toolName: tool, creditsUsed, userId, timestamp: payload.timestamp });
+      logger.error('Failed to report usage; queued for retry', error, {
+        tool,
+        creditsUsed,
+        requestId,
+        idempotencyKey
+      });
+      await this._appendPendingUsage({
+        toolName: tool,
+        creditsUsed,
+        userId,
+        timestamp: payload.timestamp,
+        requestId,
+        idempotencyKey
+      });
     }
   }
 
@@ -278,18 +339,37 @@ class AuthManager {
         // File absent or corrupt — start fresh
       }
 
-      entries.push(entry);
+      // Audit phase A2: stamp every pending entry with a request ID and idempotency key
+      // so the backend (when it ships support) can dedupe, and so we can log dropped
+      // entries by ID when the flush retry path fails permanently.
+      const stamped = {
+        requestId: entry.requestId || randomUUID(),
+        idempotencyKey: entry.idempotencyKey || randomUUID(),
+        ...entry
+      };
+
+      entries.push(stamped);
 
       // Cap at 1 MB — drop oldest entries until serialized size fits
       let serialized = JSON.stringify(entries);
+      const dropped = [];
       while (serialized.length > 1_048_576 && entries.length > 1) {
-        entries.shift();
+        dropped.push(entries.shift());
         serialized = JSON.stringify(entries);
       }
+      if (dropped.length > 0) {
+        logger.warn('Pending usage queue truncated to 1 MB cap', {
+          droppedCount: dropped.length,
+          droppedIds: dropped.map(d => d.requestId).filter(Boolean)
+        });
+      }
 
       await fs.writeFile(this.pendingUsagePath, serialized, { mode: 0o600 });
     } catch (error) {
-      console.error('Failed to append pending usage:', error.message);
+      logger.error('Failed to append pending usage', error, {
+        toolName: entry?.toolName,
+        requestId: entry?.requestId
+      });
     }
   }
 
@@ -300,34 +380,62 @@ class AuthManager {
     try {
       const raw = await fs.readFile(this.pendingUsagePath, 'utf-8');
       entries = JSON.parse(raw);
-    } catch {
-      return; // Nothing to flush
+    } catch (err) {
+      // ENOENT is normal (nothing pending). Anything else is corruption — log it.
+      if (err && err.code !== 'ENOENT') {
+        logger.warn('Pending usage file unreadable; treating as empty', {
+          error: err.message,
+          path: this.pendingUsagePath
+        });
+      }
+      return;
     }
 
     if (!Array.isArray(entries) || entries.length === 0) return;
 
     const remaining = [];
+    const flushedIds = [];
+    const failedIds = [];
     for (const entry of entries) {
       try {
+        const idempotencyKey = entry.idempotencyKey || randomUUID();
         await fetch(`${this.apiEndpoint}/api/v1/usage`, {
           method: 'POST',
           headers: {
             'Content-Type': 'application/json',
-            'X-API-Key': this.config.apiKey
+            'X-API-Key': this.config.apiKey,
+            'Idempotency-Key': idempotencyKey
           },
           body: JSON.stringify({
             tool: entry.toolName,
             creditsUsed: entry.creditsUsed,
             timestamp: entry.timestamp,
+            requestId: entry.requestId,
+            idempotencyKey,
             version: '3.0.3'
           }),
           signal: AbortSignal.timeout(5000)
         });
-      } catch {
+        flushedIds.push(entry.requestId);
+      } catch (err) {
+        failedIds.push(entry.requestId);
         remaining.push(entry);
       }
     }
 
+    if (flushedIds.length > 0) {
+      logger.info('Flushed pending usage entries', {
+        count: flushedIds.length,
+        requestIds: flushedIds.filter(Boolean)
+      });
+    }
+    if (failedIds.length > 0) {
+      logger.warn('Pending usage entries failed to flush; retained for next attempt', {
+        count: failedIds.length,
+        requestIds: failedIds.filter(Boolean)
+      });
+    }
+
     try {
       if (remaining.length === 0) {
         await fs.unlink(this.pendingUsagePath);
@@ -335,7 +443,9 @@ class AuthManager {
         await fs.writeFile(this.pendingUsagePath, JSON.stringify(remaining), { mode: 0o600 });
       }
     } catch (error) {
-      console.error('Failed to update pending usage file:', error.message);
+      logger.error('Failed to update pending usage file', error, {
+        path: this.pendingUsagePath
+      });
     }
   }
 
@@ -372,7 +482,10 @@ class AuthManager {
       track_changes: 3,
       
       // Phase 1: LLM-Powered Structured Extraction
-      extract_structured: 4
+      extract_structured: 4,
+
+      // Phase C5: Natural-language LLM extraction (external paid API call per invocation)
+      extract_with_llm: 5
     };
 
     return costs[tool] || 1;

package/src/core/BrowserContextPool.js

@@ -0,0 +1,187 @@
+/**
+ * BrowserContextPool — bounded Playwright browser-context pool.
+ *
+ * Replaces the unbounded `this.contexts = new Map()` in StealthBrowserManager
+ * with a pool that:
+ *   - enforces a hard cap (MAX_BROWSER_CONTEXTS, default 10)
+ *   - disposes contexts after N uses (periodicRefreshAfter, default 200)
+ *   - closes idle contexts after a configurable timeout
+ *   - maintains a concurrency wait-queue so excess callers fail fast
+ *     (timeout: waitTimeoutMs, default 10 000 ms) rather than accumulating
+ *
+ * The Map-compatible surface (get/set/delete/entries/clear/size) lets
+ * StealthBrowserManager adopt it with minimal changes.
+ */
+
+const DEFAULT_MAX_CONTEXTS = parseInt(process.env.MAX_BROWSER_CONTEXTS || '10', 10);
+const DEFAULT_PERIODIC_REFRESH_AFTER = 200;   // context uses before forced close+relaunch
+const DEFAULT_CLOSE_IDLE_AFTER_MS = 5 * 60 * 1000; // 5 minutes
+const DEFAULT_WAIT_TIMEOUT_MS = 10_000;
+
+export class BrowserContextPool {
+  /**
+   * @param {Object} [opts]
+   * @param {number}   [opts.maxContexts]
+   * @param {number}   [opts.periodicRefreshAfter] — max uses per context before disposal
+   * @param {number}   [opts.closeIdleAfterMs]
+   * @param {number}   [opts.waitTimeoutMs] — max wait for a free slot; fails fast after
+   * @param {Function} [opts.onContextExpired] — async (contextId, contextData) => void
+   */
+  constructor(opts = {}) {
+    this._maxContexts = opts.maxContexts ?? DEFAULT_MAX_CONTEXTS;
+    this._periodicRefreshAfter = opts.periodicRefreshAfter ?? DEFAULT_PERIODIC_REFRESH_AFTER;
+    this._closeIdleAfterMs = opts.closeIdleAfterMs ?? DEFAULT_CLOSE_IDLE_AFTER_MS;
+    this._waitTimeoutMs = opts.waitTimeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+    this._onContextExpired = opts.onContextExpired || null;
+
+    /** @type {Map<string, { context: any, fingerprint: any, config: any, uses: number, lastUsed: number, created: number }>} */
+    this._contexts = new Map();
+
+    /** Pending callers waiting for a free slot */
+    this._waitQueue = [];
+
+    /** Periodic idle-checker timer */
+    this._idleTimer = setInterval(() => this._closeIdleContexts(), Math.min(this._closeIdleAfterMs, 60_000));
+    this._idleTimer.unref?.(); // don't prevent process exit
+  }
+
+  // ── Map-compatible surface ──────────────────────────────────────────────────
+
+  get size() { return this._contexts.size; }
+
+  get(contextId) { return this._contexts.get(contextId) ?? undefined; }
+
+  has(contextId) { return this._contexts.has(contextId); }
+
+  entries() { return this._contexts.entries(); }
+
+  keys() { return this._contexts.keys(); }
+
+  values() { return this._contexts.values(); }
+
+  /**
+   * Register a context.  Throws if the pool is full and no slot becomes
+   * available within waitTimeoutMs.
+   */
+  async set(contextId, contextData) {
+    if (this._contexts.size >= this._maxContexts) {
+      await this._waitForSlot();
+    }
+    this._contexts.set(contextId, {
+      ...contextData,
+      uses: 0,
+      lastUsed: Date.now(),
+      created: Date.now()
+    });
+    return this;
+  }
+
+  /**
+   * Synchronous set — for callers that already verified there is capacity.
+   * Throws immediately if pool is at capacity.
+   */
+  setSync(contextId, contextData) {
+    if (this._contexts.size >= this._maxContexts) {
+      throw new Error(`BrowserContextPool is at capacity (${this._maxContexts} contexts). Use await pool.set() to wait for a free slot.`);
+    }
+    this._contexts.set(contextId, {
+      ...contextData,
+      uses: 0,
+      lastUsed: Date.now(),
+      created: Date.now()
+    });
+    return this;
+  }
+
+  delete(contextId) {
+    const deleted = this._contexts.delete(contextId);
+    if (deleted) this._notifyWaiter();
+    return deleted;
+  }
+
+  clear() {
+    this._contexts.clear();
+    // Drain any waiters with rejections so they don't hang
+    const waiters = this._waitQueue.splice(0);
+    waiters.forEach(({ reject }) => reject(new Error('BrowserContextPool cleared')));
+  }
+
+  // ── Pool-specific API ───────────────────────────────────────────────────────
+
+  /**
+   * Record a use for the given context.
+   * Returns true if the context should be closed and re-created (refresh needed).
+   * @param {string} contextId
+   */
+  recordUse(contextId) {
+    const entry = this._contexts.get(contextId);
+    if (!entry) return false;
+    entry.uses++;
+    entry.lastUsed = Date.now();
+    return entry.uses >= this._periodicRefreshAfter;
+  }
+
+  /**
+   * Dispose a context (close it + remove from pool).
+   * @param {string} contextId
+   */
+  async dispose(contextId) {
+    const entry = this._contexts.get(contextId);
+    if (!entry) return;
+    this._contexts.delete(contextId);
+    this._notifyWaiter();
+    try {
+      await entry.context?.close();
+    } catch {
+      // ignore close errors
+    }
+    this._onContextExpired?.(contextId, entry);
+  }
+
+  /**
+   * Close all idle contexts (lastUsed > closeIdleAfterMs ago).
+   */
+  async _closeIdleContexts() {
+    const now = Date.now();
+    for (const [contextId, entry] of this._contexts.entries()) {
+      if (now - entry.lastUsed > this._closeIdleAfterMs) {
+        await this.dispose(contextId);
+      }
+    }
+  }
+
+  /**
+   * Wait until a slot becomes available (or time out).
+   */
+  _waitForSlot() {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const idx = this._waitQueue.findIndex(w => w.resolve === resolve);
+        if (idx !== -1) this._waitQueue.splice(idx, 1);
+        reject(new Error(`BrowserContextPool: timed out waiting for a free context slot after ${this._waitTimeoutMs}ms`));
+      }, this._waitTimeoutMs);
+
+      this._waitQueue.push({ resolve, reject, timer });
+    });
+  }
+
+  /** Notify the oldest pending waiter that a slot is now free. */
+  _notifyWaiter() {
+    if (this._waitQueue.length === 0) return;
+    const { resolve, timer } = this._waitQueue.shift();
+    clearTimeout(timer);
+    resolve();
+  }
+
+  /** Destroy the pool — closes all contexts and clears the idle timer. */
+  async destroy() {
+    clearInterval(this._idleTimer);
+    for (const contextId of Array.from(this._contexts.keys())) {
+      await this.dispose(contextId);
+    }
+    const waiters = this._waitQueue.splice(0);
+    waiters.forEach(({ reject }) => reject(new Error('BrowserContextPool destroyed')));
+  }
+}
+
+export default BrowserContextPool;

package/src/core/JobManager.js

@@ -573,11 +573,13 @@ export class JobManager extends EventEmitter {
    * @returns {boolean} Whether job is valid
    */
   validateJob(job) {
-    return job &&
-           typeof job.id === 'string' &&
-           typeof job.type === 'string' &&
-           typeof job.status === 'string' &&
-           Object.values(this.JOB_STATES).includes(job.status);
+    return Boolean(
+      job &&
+      typeof job.id === 'string' &&
+      typeof job.type === 'string' &&
+      typeof job.status === 'string' &&
+      Object.values(this.JOB_STATES).includes(job.status)
+    );
   }
 
   /**

package/src/core/LocalizationManager.js

@@ -63,47 +63,11 @@ const LANGUAGE_MAPPINGS = {
 // RTL Languages Configuration
 const RTL_LANGUAGES = new Set(['ar', 'he', 'fa', 'ur', 'ku', 'dv']);
 
-// Proxy Provider Configuration
-const PROXY_PROVIDERS = {
-  regions: {
-    'us-east': { endpoint: 'proxy-us-east.example.com', port: 8080 },
-    'us-west': { endpoint: 'proxy-us-west.example.com', port: 8080 },
-    'eu-west': { endpoint: 'proxy-eu-west.example.com', port: 8080 },
-    'eu-central': { endpoint: 'proxy-eu-central.example.com', port: 8080 },
-    'eu-north': { endpoint: 'proxy-eu-north.example.com', port: 8080 },
-    'eu-east': { endpoint: 'proxy-eu-east.example.com', port: 8080 },
-    'asia-pacific': { endpoint: 'proxy-asia-pacific.example.com', port: 8080 },
-    'middle-east': { endpoint: 'proxy-middle-east.example.com', port: 8080 },
-    'south-america': { endpoint: 'proxy-south-america.example.com', port: 8080 },
-    'north-america': { endpoint: 'proxy-north-america.example.com', port: 8080 },
-    'africa': { endpoint: 'proxy-africa.example.com', port: 8080 }
-  },
-  fallbackStrategies: {
-    'geo-blocked': ['rotate-proxy', 'change-user-agent', 'delay-request'],
-    'rate-limited': ['change-proxy', 'exponential-backoff'],
-    'detection': ['rotate-fingerprint', 'change-proxy', 'human-delay']
-  }
-};
-
-// Translation Service Configuration
-const TRANSLATION_SERVICES = {
-  google: {
-    enabled: process.env.GOOGLE_TRANSLATE_API_KEY ? true : false,
-    apiKey: process.env.GOOGLE_TRANSLATE_API_KEY,
-    endpoint: 'https://translation.googleapis.com/language/translate/v2'
-  },
-  azure: {
-    enabled: process.env.AZURE_TRANSLATE_KEY ? true : false,
-    key: process.env.AZURE_TRANSLATE_KEY,
-    region: process.env.AZURE_TRANSLATE_REGION || 'global',
-    endpoint: 'https://api.cognitive.microsofttranslator.com/translate'
-  },
-  libre: {
-    enabled: process.env.LIBRE_TRANSLATE_URL ? true : false,
-    url: process.env.LIBRE_TRANSLATE_URL,
-    apiKey: process.env.LIBRE_TRANSLATE_API_KEY
-  }
-};
+// NOTE (v3.0.19 cleanup): PROXY_PROVIDERS and TRANSLATION_SERVICES configs were
+// removed. They pointed at `*.example.com` endpoints and translation services
+// that were never wired up — pure dead code. If/when real proxy rotation or
+// translation lands, configure providers explicitly rather than reviving these
+// placeholders. See IMPROVEMENT_PLAN.md §A3.
 
 const LocalizationSchema = z.object({
   countryCode: z.string().length(2).optional(),
@@ -237,27 +201,21 @@ export class LocalizationManager extends EventEmitter {
     try {
       // Pre-populate timezone mappings
       await this.loadTimezoneData();
-      
+
       // Initialize geo-location data
       await this.loadGeoLocationData();
-      
-      // Initialize proxy configurations
-      await this.initializeProxySystem();
-      
-      // Initialize translation services
-      await this.initializeTranslationServices();
-      
+
       // Load cultural browsing patterns
       await this.loadCulturalPatterns();
-      
+
       // Setup periodic health checks
       this.setupHealthChecks();
-      
+
       this.emit('initialized');
     } catch (error) {
-      this.emit('error', { 
-        type: 'initialization_failed', 
-        error: error.message 
+      this.emit('error', {
+        type: 'initialization_failed',
+        error: error.message
       });
       throw error;
     }
@@ -958,76 +916,6 @@ export class LocalizationManager extends EventEmitter {
     
     return null;
   }
-  /**
-   * Initialize proxy system with regional configurations
-   */
-  async initializeProxySystem() {
-    try {
-      // Load proxy configurations from environment or config
-      for (const [region, config] of Object.entries(PROXY_PROVIDERS.regions)) {
-        if (process.env[`PROXY_${region.toUpperCase().replace('-', '_')}_ENABLED`] === 'true') {
-          this.proxyManager.activeProxies.set(region, {
-            ...config,
-            username: process.env[`PROXY_${region.toUpperCase().replace('-', '_')}_USERNAME`],
-            password: process.env[`PROXY_${region.toUpperCase().replace('-', '_')}_PASSWORD`],
-            healthScore: 100,
-            lastCheck: 0,
-            failureCount: 0
-          });
-        }
-      }
-      
-      // Setup proxy health monitoring
-      if (this.proxyManager.activeProxies.size > 0) {
-        await this.performProxyHealthChecks();
-      }
-      
-    } catch (error) {
-      console.warn('Failed to initialize proxy system:', error.message);
-    }
-  }
-  
-  /**
-   * Initialize translation services
-   */
-  async initializeTranslationServices() {
-    try {
-      // Google Translate
-      if (TRANSLATION_SERVICES.google.enabled) {
-        this.translationProviders.set('google', {
-          type: 'google',
-          apiKey: TRANSLATION_SERVICES.google.apiKey,
-          endpoint: TRANSLATION_SERVICES.google.endpoint,
-          available: true
-        });
-      }
-      
-      // Azure Translator
-      if (TRANSLATION_SERVICES.azure.enabled) {
-        this.translationProviders.set('azure', {
-          type: 'azure',
-          key: TRANSLATION_SERVICES.azure.key,
-          region: TRANSLATION_SERVICES.azure.region,
-          endpoint: TRANSLATION_SERVICES.azure.endpoint,
-          available: true
-        });
-      }
-      
-      // LibreTranslate
-      if (TRANSLATION_SERVICES.libre.enabled) {
-        this.translationProviders.set('libre', {
-          type: 'libre',
-          url: TRANSLATION_SERVICES.libre.url,
-          apiKey: TRANSLATION_SERVICES.libre.apiKey,
-          available: true
-        });
-      }
-      
-    } catch (error) {
-      console.warn('Failed to initialize translation services:', error.message);
-    }
-  }
-  
   /**
    * Load cultural browsing patterns for different regions
    */
@@ -1612,4 +1500,5 @@ export class LocalizationManager extends EventEmitter {
 export default LocalizationManager;
 
 // Export constants for external use
-export { SUPPORTED_COUNTRIES, RTL_LANGUAGES, PROXY_PROVIDERS, TRANSLATION_SERVICES };
+// (PROXY_PROVIDERS / TRANSLATION_SERVICES removed in v3.0.19 — see §A3 of IMPROVEMENT_PLAN.md)
+export { SUPPORTED_COUNTRIES, RTL_LANGUAGES };