fca-neokex-fix 1.0.1

package/src/utils/headers.js

@@ -0,0 +1,199 @@
+"use strict";
+
+const { randomUserAgent, generateUserAgentByPersona } = require("./user-agents");
+
+const LOCALE_PROFILES = [
+    'en-US,en;q=0.9',
+    'en-GB,en;q=0.9,en-US;q=0.8',
+    'en-US,en;q=0.9,es;q=0.8',
+    'en-US,en;q=0.9,fr;q=0.8',
+    'en-CA,en;q=0.9,fr;q=0.8',
+    'en-AU,en;q=0.9,en-GB;q=0.8'
+];
+
+const TIMEZONE_OFFSETS = [-480, -420, -360, -300, -240, -180, -120, 0, 60, 120, 180, 240, 300, 360, 480, 540, 600];
+
+function getRandomLocale() {
+    return LOCALE_PROFILES[Math.floor(Math.random() * LOCALE_PROFILES.length)];
+}
+
+function getRandomTimezone() {
+    return TIMEZONE_OFFSETS[Math.floor(Math.random() * TIMEZONE_OFFSETS.length)];
+}
+
+/**
+ * Generates a comprehensive and realistic set of headers for requests to Facebook.
+ * @param {string} url - The target URL.
+ * @param {object} options - Global options from context.
+ * @param {object} ctx - The application context (containing fb_dtsg, lsd, etc.).
+ * @param {object} customHeader - Any extra headers to merge.
+ * @param {string} requestType - Type of request: 'xhr' for GraphQL/AJAX or 'navigate' for page navigation
+ * @returns {object} A complete headers object.
+ */
+function getHeaders(url, options, ctx, customHeader, requestType = 'navigate') {
+    const persona = options?.persona || 'desktop';
+    const isAndroid = persona === 'android' || persona === 'mobile';
+
+    let userAgent, secChUa, secChUaFullVersionList, secChUaPlatform, secChUaPlatformVersion;
+    let androidData = null;
+
+    if (isAndroid) {
+        if (options && options.cachedAndroidUA) {
+            userAgent = options.cachedAndroidUA;
+            androidData = {
+                resolution: options.cachedAndroidResolution,
+                locale: options.cachedAndroidLocale,
+                device: options.cachedAndroidDevice
+            };
+        } else {
+            const generated = generateUserAgentByPersona('android', options);
+            userAgent = generated.userAgent;
+            androidData = {
+                resolution: generated.resolution,
+                locale: generated.locale,
+                device: generated.device
+            };
+        }
+    } else {
+        if (options && options.cachedUserAgent) {
+            userAgent = options.cachedUserAgent;
+            secChUa = options.cachedSecChUa;
+            secChUaFullVersionList = options.cachedSecChUaFullVersionList;
+            secChUaPlatform = options.cachedSecChUaPlatform;
+            secChUaPlatformVersion = options.cachedSecChUaPlatformVersion;
+        } else {
+            const generated = randomUserAgent();
+            userAgent = generated.userAgent;
+            secChUa = generated.secChUa;
+            secChUaFullVersionList = generated.secChUaFullVersionList;
+            secChUaPlatform = generated.secChUaPlatform;
+            secChUaPlatformVersion = generated.secChUaPlatformVersion;
+        }
+    }
+
+    const host = new URL(url).hostname;
+    const referer = `https://${host}/`;
+
+    const isXhr = requestType === 'xhr';
+
+    const locales = options?.cachedLocale || (androidData?.locale ? androidData.locale.replace('_', '-') : getRandomLocale());
+    const timezone = options?.cachedTimezone || getRandomTimezone();
+
+    if (isAndroid) {
+        const headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Host': host,
+            'Connection': 'keep-alive',
+            'User-Agent': userAgent,
+            'Accept': '*/*',
+            'Accept-Language': locales,
+            'Accept-Encoding': 'gzip, deflate',
+            'X-FB-HTTP-Engine': 'Liger'
+        };
+
+        if (androidData && androidData.resolution) {
+            headers['X-FB-Client-Density'] = String(androidData.resolution.density);
+        }
+
+        if (ctx) {
+            if (ctx.lsd || ctx.fb_dtsg) {
+                headers['X-Fb-Lsd'] = ctx.lsd || ctx.fb_dtsg;
+            }
+            if (ctx.region) {
+                headers['X-MSGR-Region'] = ctx.region;
+            }
+            if (ctx.master) {
+                const { __spin_r, __spin_b, __spin_t } = ctx.master;
+                if (__spin_r) headers['X-Fb-Spin-R'] = String(__spin_r);
+                if (__spin_b) headers['X-Fb-Spin-B'] = String(__spin_b);
+                if (__spin_t) headers['X-Fb-Spin-T'] = String(__spin_t);
+            }
+        }
+
+        if (customHeader) {
+            Object.assign(headers, customHeader);
+            if (customHeader.noRef) {
+                delete headers.Referer;
+            }
+        }
+
+        return headers;
+    }
+
+    const isWindows = secChUaPlatform === '"Windows"';
+    const isMac = secChUaPlatform === '"macOS"';
+    const isLinux = secChUaPlatform === '"Linux"';
+
+    const headers = {
+        'Accept': isXhr ? '*/*' : 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+        'Accept-Language': locales,
+        'Accept-Encoding': 'gzip, deflate, br',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'DNT': '1',
+        'Dpr': '1',
+        'Host': host,
+        'Pragma': 'no-cache',
+        'Referer': referer,
+        'Sec-Ch-Prefers-Color-Scheme': 'light',
+        'Sec-Ch-Ua': secChUa,
+        'Sec-Ch-Ua-Full-Version-List': secChUaFullVersionList,
+        'Sec-Ch-Ua-Mobile': '?0',
+        'Sec-Ch-Ua-Model': '""',
+        'Sec-Ch-Ua-Platform': secChUaPlatform,
+        'Sec-Ch-Ua-Platform-Version': secChUaPlatformVersion,
+        'Sec-Fetch-Dest': isXhr ? 'empty' : 'document',
+        'Sec-Fetch-Mode': isXhr ? 'cors' : 'navigate',
+        'Sec-Fetch-Site': isXhr ? 'same-origin' : 'none',
+        'User-Agent': userAgent,
+        'Viewport-Width': '1920',
+        'X-FB-Timezone-Offset': String(timezone * 60)
+    };
+
+    if (isWindows || isMac || isLinux) {
+        headers['Sec-Ch-Ua-Arch'] = '"x86"';
+        headers['Sec-Ch-Ua-Bitness'] = '"64"';
+    }
+
+    if (isXhr) {
+        headers['Origin'] = `https://${host}`;
+        headers['X-Requested-With'] = 'XMLHttpRequest';
+    } else {
+        headers['Sec-Fetch-User'] = '?1';
+        headers['Upgrade-Insecure-Requests'] = '1';
+    }
+
+    if (ctx) {
+        if (ctx.lsd || ctx.fb_dtsg) {
+            headers['X-Fb-Lsd'] = ctx.lsd || ctx.fb_dtsg;
+        }
+        if (ctx.region) {
+            headers['X-MSGR-Region'] = ctx.region;
+        }
+        if (ctx.master) {
+            const { __spin_r, __spin_b, __spin_t } = ctx.master;
+            if (__spin_r) headers['X-Fb-Spin-R'] = String(__spin_r);
+            if (__spin_b) headers['X-Fb-Spin-B'] = String(__spin_b);
+            if (__spin_t) headers['X-Fb-Spin-T'] = String(__spin_t);
+        }
+    }
+
+
+    if (customHeader) {
+        Object.assign(headers, customHeader);
+        if (customHeader.noRef) {
+            delete headers.Referer;
+        }
+    }
+
+    return headers;
+}
+
+const meta = (prop) => new RegExp(`<meta property="${prop}" content="([^"]*)"`);
+
+module.exports = {
+    getHeaders,
+    meta,
+    getRandomLocale,
+    getRandomTimezone
+};

package/src/utils/index.js

@@ -0,0 +1,151 @@
+/* eslint-disable no-prototype-builtins */
+"use strict";
+
+const cheerio = require("cheerio");
+const util = require("util");
+
+/**
+ * Fetches a URL, scrapes all <script type="application/json"> tags, and returns their parsed content.
+ * @param {string} url - The URL to fetch.
+ * @param {object} jar - The cookie jar.
+ * @param {object} qs - Query string parameters.
+ * @param {object} options - Global options.
+ * @param {object} ctx - The application context.
+ * @param {object} customHeader - Custom headers.
+ * @returns {Promise<Array<Object>>} A promise that resolves with an array of parsed JSON objects.
+ */
+async function json(url, jar, qs, options, ctx, customHeader) {
+  const network = require("./axios");
+  const constants = require("./constants");
+  
+  try {
+    const res = await network.get(url, jar, qs, options, ctx, customHeader);
+    const body = res.body;
+    const $ = cheerio.load(body);
+    const scripts = $('script[type="application/json"]');
+
+    if (scripts.length === 0) {
+      constants.warn(`No <script type="application/json"> tags found on ${url}`);
+      return [];
+    }
+
+    const allJsonData = [];
+    scripts.each((index, element) => {
+      try {
+        const jsonContent = $(element).html();
+        if (jsonContent) {
+          allJsonData.push(JSON.parse(jsonContent));
+        }
+      } catch (e) {
+        constants.warn(`Could not parse JSON from script #${index + 1} on ${url}`);
+      }
+    });
+
+    return allJsonData;
+  } catch (error) {
+    constants.error(`Error in utils.json fetching from ${url}:`, error);
+    throw error;
+  }
+}
+
+/**
+ * Creates an object with pre-filled request defaults based on HTML and user context.
+ * @param {string} html - The HTML content.
+ * @param {string|number} userID - The user ID.
+ * @param {object} ctx - The context containing session data.
+ * @returns {object} An object with .get, .post, and .postFormData methods.
+ */
+function makeDefaults(html, userID, ctx) {
+  const network = require("./axios");
+  const constants = require("./constants");
+  
+  let reqCounter = 1;
+  const revision = constants.getFrom(html, 'revision":', ",");
+
+  /**
+   * Merges provided data with default request parameters.
+   * @param {object} obj - The original query or form object.
+   * @returns {object} The merged object.
+   */
+  function mergeWithDefaults(obj) {
+    const newObj = {
+      av: userID,
+      __user: userID,
+      __req: (reqCounter++).toString(36),
+      __rev: revision,
+      __a: 1,
+      ...(ctx && {
+        fb_dtsg: ctx.fb_dtsg,
+        jazoest: ctx.jazoest,
+      }),
+    };
+
+    if (!obj) return newObj;
+
+    for (const prop in obj) {
+      if (obj.hasOwnProperty(prop) && !newObj[prop]) {
+        newObj[prop] = obj[prop];
+      }
+    }
+
+    return newObj;
+  }
+
+  return {
+    /**
+     * Makes a GET request with merged defaults.
+     * @param {string} url
+     * @param {object} jar
+     * @param {object} qs
+     * @param {object} ctxx
+     * @param {object} [customHeader={}]
+     * @returns {Promise<object>}
+     */
+    get: (url, jar, qs, ctxx, customHeader = {}) =>
+      network.get(url, jar, mergeWithDefaults(qs), ctx.globalOptions, ctxx || ctx, customHeader),
+
+    /**
+     * Makes a POST request with merged defaults.
+     * @param {string} url
+     * @param {object} jar
+     * @param {object} form
+     * @param {object} ctxx
+     * @param {object} [customHeader={}]
+     * @returns {Promise<object>}
+     */
+    post: (url, jar, form, ctxx, customHeader = {}) =>
+      network.post(url, jar, mergeWithDefaults(form), ctx.globalOptions, ctxx || ctx, customHeader),
+
+    /**
+     * Makes a multipart/form-data POST request with merged defaults.
+     * @param {string} url
+     * @param {object} jar
+     * @param {object} form
+     * @param {object} qs
+     * @param {object} ctxx
+     * @returns {Promise<object>}
+     */
+    postFormData: (url, jar, form, qs, ctxx) =>
+      network.postFormData(
+        url,
+        jar,
+        mergeWithDefaults(form),
+        mergeWithDefaults(qs),
+        ctx.globalOptions,
+        ctxx || ctx
+      ),
+  };
+}
+
+module.exports = {
+  ...require('./axios'),
+  ...require('./clients'),
+  ...require('./constants'),
+  ...require('./formatters'),
+  ...require('./headers'),
+  ...require('./user-agents'),
+  json,
+  makeDefaults,
+  promisify: (func) => util.promisify(func),
+  delay: (ms) => new Promise(r => setTimeout(r, ms))
+};

package/src/utils/monitoring.js

@@ -0,0 +1,358 @@
+"use strict";
+
+const utils = require('./index');
+const chalk = require('chalk');
+const gradient = require('gradient-string');
+
+class ProductionMonitor {
+    constructor() {
+        this.metrics = {
+            requests: {
+                total: 0,
+                success: 0,
+                failed: 0,
+                byEndpoint: new Map()
+            },
+            errors: {
+                total: 0,
+                byType: new Map(),
+                byCode: new Map(),
+                recent: []
+            },
+            performance: {
+                avgResponseTime: 0,
+                slowRequests: [],
+                requestTimes: []
+            },
+            session: {
+                loginTime: null,
+                lastActivity: null,
+                tokenRefreshCount: 0,
+                reconnectCount: 0
+            },
+            rateLimiting: {
+                hitCount: 0,
+                cooldowns: 0,
+                delayedRequests: 0
+            }
+        };
+        
+        this.config = {
+            logLevel: 'info',
+            enableMetrics: true,
+            enableErrorTracking: true,
+            performanceThreshold: 5000,
+            errorRetentionCount: 100,
+            metricsInterval: 60000
+        };
+        
+        this.startTime = Date.now();
+        this.metricsInterval = null;
+    }
+
+    setConfig(options) {
+        Object.assign(this.config, options);
+    }
+
+    trackRequest(endpoint, success, responseTime, error = null) {
+        if (!this.config.enableMetrics) return;
+        
+        this.metrics.requests.total++;
+        if (success) {
+            this.metrics.requests.success++;
+        } else {
+            this.metrics.requests.failed++;
+        }
+        
+        if (!this.metrics.requests.byEndpoint.has(endpoint)) {
+            this.metrics.requests.byEndpoint.set(endpoint, {
+                total: 0,
+                success: 0,
+                failed: 0,
+                avgTime: 0
+            });
+        }
+        
+        const endpointStats = this.metrics.requests.byEndpoint.get(endpoint);
+        endpointStats.total++;
+        if (success) {
+            endpointStats.success++;
+        } else {
+            endpointStats.failed++;
+        }
+        
+        endpointStats.avgTime = 
+            (endpointStats.avgTime * (endpointStats.total - 1) + responseTime) / endpointStats.total;
+        
+        this.trackPerformance(endpoint, responseTime);
+        
+        if (error) {
+            this.trackError(error, endpoint);
+        }
+        
+        this.metrics.session.lastActivity = Date.now();
+    }
+
+    trackPerformance(endpoint, responseTime) {
+        this.metrics.performance.requestTimes.push(responseTime);
+        
+        if (this.metrics.performance.requestTimes.length > 1000) {
+            this.metrics.performance.requestTimes.shift();
+        }
+        
+        const sum = this.metrics.performance.requestTimes.reduce((a, b) => a + b, 0);
+        this.metrics.performance.avgResponseTime = 
+            sum / this.metrics.performance.requestTimes.length;
+        
+        if (responseTime > this.config.performanceThreshold) {
+            this.metrics.performance.slowRequests.push({
+                endpoint,
+                responseTime,
+                timestamp: Date.now()
+            });
+            
+            if (this.metrics.performance.slowRequests.length > 50) {
+                this.metrics.performance.slowRequests.shift();
+            }
+            
+            const perfGradient = gradient(['#ff6b6b', '#ee5a6f']);
+            utils.warn(
+                chalk.bold("Performance"), 
+                `Slow request: ${chalk.cyan(endpoint)} took ${perfGradient(responseTime + 'ms')}`
+            );
+        }
+    }
+
+    trackError(error, context = '') {
+        if (!this.config.enableErrorTracking) return;
+        
+        this.metrics.errors.total++;
+        
+        const errorType = error.errorType || error.name || 'UnknownError';
+        const errorCode = error.errorCode || error.code || 'N/A';
+        
+        this.metrics.errors.byType.set(
+            errorType,
+            (this.metrics.errors.byType.get(errorType) || 0) + 1
+        );
+        
+        this.metrics.errors.byCode.set(
+            errorCode,
+            (this.metrics.errors.byCode.get(errorCode) || 0) + 1
+        );
+        
+        this.metrics.errors.recent.push({
+            type: errorType,
+            code: errorCode,
+            message: error.message,
+            context,
+            timestamp: Date.now(),
+            stack: error.stack
+        });
+        
+        if (this.metrics.errors.recent.length > this.config.errorRetentionCount) {
+            this.metrics.errors.recent.shift();
+        }
+    }
+
+    trackRateLimit(type, threadID = null) {
+        this.metrics.rateLimiting.hitCount++;
+        
+        if (type === 'cooldown') {
+            this.metrics.rateLimiting.cooldowns++;
+        } else if (type === 'delayed') {
+            this.metrics.rateLimiting.delayedRequests++;
+        }
+    }
+
+    trackTokenRefresh() {
+        this.metrics.session.tokenRefreshCount++;
+    }
+
+    trackReconnect() {
+        this.metrics.session.reconnectCount++;
+    }
+
+    setLoginTime() {
+        this.metrics.session.loginTime = Date.now();
+    }
+
+    getMetrics() {
+        const uptime = Date.now() - this.startTime;
+        const sessionDuration = this.metrics.session.loginTime 
+            ? Date.now() - this.metrics.session.loginTime 
+            : 0;
+        
+        return {
+            uptime,
+            sessionDuration,
+            requests: {
+                ...this.metrics.requests,
+                byEndpoint: Object.fromEntries(this.metrics.requests.byEndpoint),
+                successRate: this.metrics.requests.total > 0
+                    ? (this.metrics.requests.success / this.metrics.requests.total * 100).toFixed(2) + '%'
+                    : 'N/A'
+            },
+            errors: {
+                ...this.metrics.errors,
+                byType: Object.fromEntries(this.metrics.errors.byType),
+                byCode: Object.fromEntries(this.metrics.errors.byCode),
+                errorRate: this.metrics.requests.total > 0
+                    ? (this.metrics.errors.total / this.metrics.requests.total * 100).toFixed(2) + '%'
+                    : 'N/A'
+            },
+            performance: this.metrics.performance,
+            session: this.metrics.session,
+            rateLimiting: this.metrics.rateLimiting
+        };
+    }
+
+    getHealth() {
+        const metrics = this.getMetrics();
+        const health = {
+            status: 'healthy',
+            checks: {},
+            timestamp: Date.now()
+        };
+        
+        const errorRate = this.metrics.requests.total > 0
+            ? (this.metrics.errors.total / this.metrics.requests.total) * 100
+            : 0;
+        
+        health.checks.errorRate = {
+            status: errorRate < 5 ? 'pass' : errorRate < 15 ? 'warn' : 'fail',
+            value: errorRate.toFixed(2) + '%',
+            threshold: '5%'
+        };
+        
+        health.checks.performance = {
+            status: this.metrics.performance.avgResponseTime < 2000 ? 'pass' : 
+                    this.metrics.performance.avgResponseTime < 5000 ? 'warn' : 'fail',
+            value: Math.round(this.metrics.performance.avgResponseTime) + 'ms',
+            threshold: '2000ms'
+        };
+        
+        health.checks.session = {
+            status: this.metrics.session.loginTime ? 'pass' : 'fail',
+            value: this.metrics.session.loginTime ? 'active' : 'not logged in'
+        };
+        
+        health.checks.rateLimiting = {
+            status: this.metrics.rateLimiting.hitCount < 100 ? 'pass' : 
+                    this.metrics.rateLimiting.hitCount < 500 ? 'warn' : 'fail',
+            value: this.metrics.rateLimiting.hitCount,
+            threshold: '100 hits'
+        };
+        
+        const failedChecks = Object.values(health.checks).filter(c => c.status === 'fail').length;
+        const warnChecks = Object.values(health.checks).filter(c => c.status === 'warn').length;
+        
+        if (failedChecks > 0) {
+            health.status = 'unhealthy';
+        } else if (warnChecks > 0) {
+            health.status = 'degraded';
+        }
+        
+        return health;
+    }
+
+    reset() {
+        this.metrics.requests.total = 0;
+        this.metrics.requests.success = 0;
+        this.metrics.requests.failed = 0;
+        this.metrics.requests.byEndpoint.clear();
+        this.metrics.errors.total = 0;
+        this.metrics.errors.byType.clear();
+        this.metrics.errors.byCode.clear();
+        this.metrics.errors.recent = [];
+        this.metrics.performance.slowRequests = [];
+        this.metrics.performance.requestTimes = [];
+        this.metrics.rateLimiting.hitCount = 0;
+        this.metrics.rateLimiting.cooldowns = 0;
+        this.metrics.rateLimiting.delayedRequests = 0;
+        
+        utils.success(chalk.bold("Monitoring"), chalk.green("All metrics have been reset successfully"));
+    }
+
+    displayHealthStatus() {
+        const health = this.getHealth();
+        const statusGradient = gradient(['#11998e', '#38ef7d']);
+        const warnGradient = gradient(['#f093fb', '#f5576c']);
+        const errorGradient = gradient(['#fa709a', '#fee140']);
+        
+        console.log('\n' + chalk.cyan('═'.repeat(60)));
+        
+        if (health.status === 'healthy') {
+            console.log(statusGradient.multiline('💚 SYSTEM HEALTH: HEALTHY'));
+        } else if (health.status === 'degraded') {
+            console.log(warnGradient.multiline('💛 SYSTEM HEALTH: DEGRADED'));
+        } else {
+            console.log(errorGradient.multiline('❤️  SYSTEM HEALTH: UNHEALTHY'));
+        }
+        
+        console.log(chalk.cyan('═'.repeat(60)));
+        
+        Object.entries(health.checks).forEach(([name, check]) => {
+            const icon = check.status === 'pass' ? '✓' : check.status === 'warn' ? '⚠' : '✖';
+            const color = check.status === 'pass' ? chalk.green : check.status === 'warn' ? chalk.yellow : chalk.red;
+            const nameFormatted = name.charAt(0).toUpperCase() + name.slice(1);
+            
+            console.log(color(`\n${icon} ${chalk.bold(nameFormatted)}:`));
+            console.log(color(`  Status: ${check.status.toUpperCase()}`));
+            console.log(color(`  Value: ${check.value}`));
+            if (check.threshold) {
+                console.log(color(`  Threshold: ${check.threshold}`));
+            }
+        });
+        
+        console.log('\n' + chalk.cyan('═'.repeat(60)) + '\n');
+        return health;
+    }
+
+    startPeriodicReporting(interval = 60000) {
+        if (this.metricsInterval) {
+            clearInterval(this.metricsInterval);
+        }
+        
+        this.metricsInterval = setInterval(() => {
+            const metrics = this.getMetrics();
+            const reportGradient = gradient(['#667eea', '#764ba2']);
+            
+            console.log('\n' + chalk.cyan('═'.repeat(60)));
+            console.log(reportGradient.multiline('📊 PERFORMANCE METRICS REPORT'));
+            console.log(chalk.cyan('═'.repeat(60)));
+            
+            console.log(chalk.bold.white('\n🔹 Requests:'));
+            console.log(`  ${chalk.gray('Total:')} ${chalk.green.bold(metrics.requests.total)}`);
+            console.log(`  ${chalk.gray('Success Rate:')} ${chalk.green(metrics.requests.successRate)}`);
+            
+            console.log(chalk.bold.white('\n🔹 Errors:'));
+            console.log(`  ${chalk.gray('Total:')} ${chalk.red.bold(metrics.errors.total)}`);
+            console.log(`  ${chalk.gray('Error Rate:')} ${chalk.yellow(metrics.errors.errorRate)}`);
+            
+            console.log(chalk.bold.white('\n🔹 Performance:'));
+            const avgTime = Math.round(metrics.performance.avgResponseTime);
+            const timeColor = avgTime < 1000 ? chalk.green : avgTime < 3000 ? chalk.yellow : chalk.red;
+            console.log(`  ${chalk.gray('Avg Response Time:')} ${timeColor(avgTime + 'ms')}`);
+            
+            console.log(chalk.bold.white('\n🔹 Rate Limiting:'));
+            console.log(`  ${chalk.gray('Total Hits:')} ${chalk.cyan(metrics.rateLimiting.hitCount)}`);
+            
+            console.log(chalk.cyan('═'.repeat(60)) + '\n');
+        }, interval);
+    }
+
+    stopPeriodicReporting() {
+        if (this.metricsInterval) {
+            clearInterval(this.metricsInterval);
+            this.metricsInterval = null;
+        }
+    }
+}
+
+const globalMonitor = new ProductionMonitor();
+
+module.exports = {
+    ProductionMonitor,
+    globalMonitor
+};