@lazyneoaz/nkxchat 1.0.0

package/src/utils/tokenRefresh.js

@@ -0,0 +1,285 @@
+"use strict";
+
+const utils = require('./index');
+const { globalAutoReLoginManager } = require('./autoReLogin');
+
+/**
+ * Token Refresh Manager
+ * Automatically refreshes fb_dtsg, lsd, and other tokens to prevent expiration
+ */
+
+class TokenRefreshManager {
+    constructor() {
+        this.refreshInterval = null;
+        this.REFRESH_INTERVAL_MS = 10 * 60 * 60 * 1000; // 10 hours
+        this.SESSION_CHECK_INTERVAL_MS = 2 * 60 * 60 * 1000; // 2 hours - reduced frequency to avoid bot detection
+        this.lastRefresh = Date.now();
+        this.lastSessionCheck = Date.now();
+        this.failureCount = 0;
+        this.MAX_FAILURES = 3;
+        this.onSessionExpiry = null;
+        this.sessionHealthCheckInterval = null;
+    }
+
+    /**
+     * Start automatic token refresh
+     * @param {Object} ctx - Application context
+     * @param {Object} defaultFuncs - Default functions
+     * @param {string} fbLink - Facebook link
+     */
+    startAutoRefresh(ctx, defaultFuncs, fbLink) {
+        if (this.refreshInterval) {
+            clearInterval(this.refreshInterval);
+            this.refreshInterval = null;
+        }
+        if (this.sessionHealthCheckInterval) {
+            clearInterval(this.sessionHealthCheckInterval);
+            this.sessionHealthCheckInterval = null;
+        }
+
+        const scheduleNext = () => {
+            const base = this.REFRESH_INTERVAL_MS;
+            const jitter = Math.floor(base * (0.2 + Math.random() * 0.4)); // 20%–60% jitter
+            const interval = base + (Math.random() > 0.5 ? jitter : -jitter);
+            this.refreshInterval = setTimeout(async () => {
+                try {
+                    await this.refreshTokens(ctx, defaultFuncs, fbLink);
+                    utils.log("TokenRefresh", "Tokens refreshed successfully");
+                } catch (error) {
+                    utils.error("TokenRefresh", "Failed to refresh tokens:", error.message);
+                } finally {
+                    scheduleNext();
+                }
+            }, interval);
+            utils.log("TokenRefresh", `Auto-refresh scheduled in ${interval}ms`);
+        };
+
+        // Start session health checks
+        this.sessionHealthCheckInterval = setInterval(async () => {
+            try {
+                const isHealthy = await this.checkSessionHealth(ctx, defaultFuncs, fbLink);
+                if (!isHealthy) {
+                    utils.warn("TokenRefresh", "Session health check failed, triggering refresh");
+                    await this.refreshTokens(ctx, defaultFuncs, fbLink);
+                }
+            } catch (error) {
+                utils.error("TokenRefresh", "Session health check error:", error.message);
+            }
+        }, this.SESSION_CHECK_INTERVAL_MS);
+
+        scheduleNext();
+    }
+
+    /**
+     * Check if session is healthy using a lightweight AJAX ping instead of a
+     * full homepage load.  Fetching the full homepage every 2 hours is a clear
+     * automation fingerprint; a small presence/ping endpoint is far less
+     * conspicuous and produces a much smaller response.
+     *
+     * @param {Object} ctx - Application context
+     * @param {Object} defaultFuncs - Default functions
+     * @param {string} fbLink - Facebook link
+     * @returns {Promise<boolean>}
+     */
+    async checkSessionHealth(ctx, defaultFuncs, fbLink) {
+        try {
+            // Use a lightweight AJAX endpoint that only returns a small JSON
+            // payload — not the full multi-megabyte homepage.
+            const probeUrl = 'https://www.facebook.com/ajax/presence/reconnect.php';
+            const probeCtx = { ...ctx, _skipSessionInspect: true };
+            const resp = await utils.get(
+                probeUrl,
+                ctx.jar,
+                { reason: 'reconnect', __a: 1, __req: 'probe' },
+                ctx.globalOptions,
+                probeCtx
+            );
+
+            const body = resp.body;
+            if (!body) return false;
+
+            const bodyStr = typeof body === 'string' ? body : JSON.stringify(body);
+
+            // If we get a login-page redirect in the probe response the session is gone
+            const isLoginPage =
+                bodyStr.includes('<form id="login_form"') ||
+                bodyStr.includes('"login_page"') ||
+                bodyStr.includes('id="loginbutton"');
+
+            if (isLoginPage) return false;
+
+            const isCheckpoint =
+                bodyStr.includes('"checkpoint"') && bodyStr.includes('"flow_type"');
+            if (isCheckpoint) return false;
+
+            this.lastSessionCheck = Date.now();
+            return true;
+        } catch (error) {
+            // A network error doesn't mean the session is gone — be conservative
+            // and only return false for clear auth failures.
+            const msg = error.message || '';
+            if (msg.includes('Not logged in') || msg.includes('Session has expired')) {
+                utils.error("TokenRefresh", "Session health check: session expired:", msg);
+                return false;
+            }
+            utils.warn("TokenRefresh", "Session health check network error (ignoring):", msg);
+            return true;
+        }
+    }
+
+    /**
+     * Manually refresh tokens with retry logic
+     * @param {Object} ctx - Application context
+     * @param {Object} defaultFuncs - Default functions
+     * @param {string} fbLink - Facebook link
+     * @param {number} retryCount - Current retry attempt (internal use)
+     * @returns {Promise<boolean>}
+     */
+    async refreshTokens(ctx, defaultFuncs, fbLink, retryCount = 0) {
+        const MAX_RETRIES = 3;
+        const RETRY_DELAYS = [2000, 5000, 10000];
+        
+        try {
+            const resp = await utils.get(fbLink, ctx.jar, null, ctx.globalOptions, { noRef: true });
+            
+            const html = resp.body;
+            if (!html) {
+                throw new Error("Empty response from Facebook");
+            }
+
+            // Precise check - broad html.includes("login") is a false positive because
+            // Facebook includes the word "login" all over authenticated pages too.
+            const isLoginPage = html.includes('<form id="login_form"') ||
+                               html.includes('id="loginbutton"') ||
+                               html.includes('"login_page"') ||
+                               html.includes('id="email" name="email"');
+            const isCheckpoint = html.includes('"checkpoint"') && html.includes('"flow_type"');
+
+            if (isLoginPage || isCheckpoint) {
+                if (isCheckpoint) {
+                    try {
+                        const { globalAntiSuspension } = require('./antiSuspension');
+                        globalAntiSuspension.tripCircuitBreaker('checkpoint_on_token_refresh', 60 * 60 * 1000);
+                    } catch (_) {}
+                }
+                throw new Error("Session expired or checkpoint required");
+            }
+
+            const dtsgMatch = html.match(/"DTSGInitialData",\[],{"token":"([^"]+)"/);
+            if (dtsgMatch) {
+                ctx.fb_dtsg = dtsgMatch[1];
+                ctx.ttstamp = "2";
+                for (let i = 0; i < ctx.fb_dtsg.length; i++) {
+                    ctx.ttstamp += ctx.fb_dtsg.charCodeAt(i);
+                }
+            } else {
+                throw new Error("Failed to extract fb_dtsg token");
+            }
+
+            const lsdMatch = html.match(/"LSD",\[],{"token":"([^"]+)"/);
+            if (lsdMatch) {
+                ctx.lsd = lsdMatch[1];
+            }
+
+            const jazoestMatch = html.match(/jazoest=(\d+)/);
+            if (jazoestMatch) {
+                ctx.jazoest = jazoestMatch[1];
+            }
+
+            const revisionMatch = html.match(/"client_revision":(\d+)/);
+            if (revisionMatch) {
+                ctx.__rev = revisionMatch[1];
+            }
+
+            this.lastRefresh = Date.now();
+            this.failureCount = 0;
+            try {
+                if (globalAutoReLoginManager && globalAutoReLoginManager.isEnabled && globalAutoReLoginManager.isEnabled()) {
+                    const appState = utils.getAppState(ctx.jar);
+                    globalAutoReLoginManager.updateAppState(appState);
+                }
+            } catch (_) {}
+            return true;
+        } catch (error) {
+            this.failureCount++;
+            utils.error("TokenRefresh", `Refresh failed (attempt ${retryCount + 1}/${MAX_RETRIES + 1}):`, error.message);
+            
+            if (this.failureCount >= this.MAX_FAILURES) {
+                utils.error("TokenRefresh", `Maximum failures (${this.MAX_FAILURES}) reached. Session may be expired.`);
+                if (this.onSessionExpiry && typeof this.onSessionExpiry === 'function') {
+                    this.onSessionExpiry(error);
+                }
+                return false;
+            }
+            
+            if (retryCount < MAX_RETRIES) {
+                const delay = RETRY_DELAYS[retryCount];
+                utils.log("TokenRefresh", `Retrying in ${delay}ms...`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+                return await this.refreshTokens(ctx, defaultFuncs, fbLink, retryCount + 1);
+            }
+            
+            return false;
+        }
+    }
+
+    /**
+     * Stop automatic token refresh
+     */
+    stopAutoRefresh() {
+        if (this.refreshInterval) {
+            clearTimeout(this.refreshInterval);
+            this.refreshInterval = null;
+            utils.log("TokenRefresh", "Auto-refresh disabled");
+        }
+        if (this.sessionHealthCheckInterval) {
+            clearInterval(this.sessionHealthCheckInterval);
+            this.sessionHealthCheckInterval = null;
+            utils.log("TokenRefresh", "Session health checks disabled");
+        }
+    }
+
+    /**
+     * Get time until next refresh
+     * @returns {number} Milliseconds until next refresh
+     */
+    getTimeUntilNextRefresh() {
+        if (!this.refreshInterval) return -1;
+        return Math.max(0, this.REFRESH_INTERVAL_MS - (Date.now() - this.lastRefresh));
+    }
+
+    /**
+     * Check if tokens need immediate refresh
+     * @returns {boolean}
+     */
+    needsImmediateRefresh() {
+        return (Date.now() - this.lastRefresh) >= this.REFRESH_INTERVAL_MS;
+    }
+
+    /**
+     * Set callback for session expiry detection
+     * @param {Function} callback - Callback function to trigger on session expiry
+     */
+    setSessionExpiryCallback(callback) {
+        this.onSessionExpiry = callback;
+    }
+
+    /**
+     * Reset failure count (useful after successful re-login)
+     */
+    resetFailureCount() {
+        this.failureCount = 0;
+    }
+
+    /**
+     * Get current failure count
+     * @returns {number}
+     */
+    getFailureCount() {
+        return this.failureCount;
+    }
+}
+
+module.exports = {
+    TokenRefreshManager
+};

package/src/utils/user-agents.js

@@ -0,0 +1,238 @@
+"use strict";
+const { getRandom } = require("./constants");
+
+const BROWSER_DATA = {
+    windows: {
+        platform: "Windows NT 10.0; Win64; x64",
+        chromeVersions: ["139.0.0.0", "131.0.6778.86", "130.0.6723.92", "129.0.6668.101", "128.0.6613.120", "127.0.6533.120"],
+        edgeVersions: ["139.0.0.0", "131.0.2903.51", "130.0.2849.68", "129.0.2792.89"],
+        platformVersion: '"15.0.0"'
+    },
+    mac: {
+        platform: "Macintosh; Intel Mac OS X 10_15_7",
+        chromeVersions: ["139.0.0.0", "131.0.6778.86", "130.0.6723.92", "129.0.6668.101", "128.0.6613.120", "127.0.6533.120"],
+        edgeVersions: ["139.0.0.0", "131.0.2903.51", "130.0.2849.68", "129.0.2792.89"],
+        platformVersion: '"14.7.0"'
+    },
+    linux: {
+        platform: "X11; Linux x86_64",
+        chromeVersions: ["139.0.0.0", "131.0.6778.86", "130.0.6723.92", "129.0.6668.101", "128.0.6613.120"],
+        edgeVersions: ["139.0.0.0", "131.0.2903.51", "130.0.2849.68"],
+        platformVersion: '""'
+    }
+};
+
+const defaultUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36";
+
+/**
+ * Generates a realistic, randomized User-Agent string and related Sec-CH headers.
+ * Supports Chrome and Edge browsers across Windows, macOS, and Linux.
+ * @returns {{userAgent: string, secChUa: string, secChUaFullVersionList: string, secChUaPlatform: string, secChUaPlatformVersion: string, browser: string}}
+ */
+function randomUserAgent() {
+    const os = getRandom(Object.keys(BROWSER_DATA));
+    const data = BROWSER_DATA[os];
+
+    const useEdge = Math.random() > 0.7 && data.edgeVersions;
+    const versions = useEdge ? data.edgeVersions : data.chromeVersions;
+    const version = getRandom(versions);
+    const majorVersion = version.split('.')[0];
+    const browserName = useEdge ? 'Microsoft Edge' : 'Google Chrome';
+    const browserIdentifier = useEdge ? 'Edg' : 'Chrome';
+
+    const userAgent = useEdge 
+        ? `Mozilla/5.0 (${data.platform}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${version} Safari/537.36 Edg/${version}`
+        : `Mozilla/5.0 (${data.platform}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${version} Safari/537.36`;
+
+    const greeseValue = Math.random() > 0.5 ? '99' : '8';
+    const brands = useEdge ? [
+        `"Chromium";v="${majorVersion}"`,
+        `"Not(A:Brand";v="${greeseValue}"`,
+        `"${browserName}";v="${majorVersion}"`
+    ] : [
+        `"${browserName}";v="${majorVersion}"`,
+        `"Not;A=Brand";v="${greeseValue}"`,
+        `"Chromium";v="${majorVersion}"`
+    ];
+
+    const secChUa = brands.join(', ');
+    const secChUaFullVersionList = brands.map(b => {
+        const match = b.match(/v="(\d+)"/);
+        if (match && match[1] === majorVersion) {
+            return b.replace(`v="${majorVersion}"`, `v="${version}"`);
+        }
+        return b;
+    }).join(', ');
+
+    const platformName = os === 'windows' ? 'Windows' : os === 'mac' ? 'macOS' : 'Linux';
+
+    return {
+        userAgent,
+        secChUa,
+        secChUaFullVersionList,
+        secChUaPlatform: `"${platformName}"`,
+        secChUaPlatformVersion: data.platformVersion,
+        browser: browserName
+    };
+}
+
+function randomInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function randomChoice(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function randomBuildId() {
+    const prefixes = ["QP1A", "RP1A", "SP1A", "TP1A", "UP1A", "AP4A"];
+    return `${randomChoice(prefixes)}.${randomInt(180000, 250000)}.${randomInt(10, 99)}`;
+}
+
+function randomResolution() {
+    const presets = [
+        { width: 720, height: 1280, density: 2.0 },
+        { width: 1080, height: 1920, density: 2.625 },
+        { width: 1080, height: 2400, density: 3.0 },
+        { width: 1440, height: 3040, density: 3.5 },
+        { width: 1440, height: 3200, density: 4.0 }
+    ];
+    return randomChoice(presets);
+}
+
+function randomFbav() {
+    return `${randomInt(390, 499)}.${randomInt(0, 3)}.${randomInt(0, 2)}.${randomInt(10, 60)}.${randomInt(100, 999)}`;
+}
+
+function randomOrcaUA() {
+    const androidVersions = ["8.1.0", "9", "10", "11", "12", "13", "14"];
+    const devices = [
+        { brand: "samsung", model: "SM-G996B" },
+        { brand: "samsung", model: "SM-S908E" },
+        { brand: "Xiaomi", model: "M2101K9AG" },
+        { brand: "OPPO", model: "CPH2219" },
+        { brand: "vivo", model: "V2109" },
+        { brand: "HUAWEI", model: "VOG-L29" },
+        { brand: "asus", model: "ASUS_I001DA" },
+        { brand: "Google", model: "Pixel 6" },
+        { brand: "realme", model: "RMX2170" }
+    ];
+    const carriers = [
+        "Viettel Telecom", "Mobifone", "Vinaphone",
+        "T-Mobile", "Verizon", "AT&T",
+        "Telkomsel", "Jio", "NTT DOCOMO",
+        "Vodafone", "Orange"
+    ];
+    const locales = [
+        "vi_VN", "en_US", "en_GB", "id_ID",
+        "th_TH", "fr_FR", "de_DE", "es_ES", "pt_BR"
+    ];
+    const archs = ["arm64-v8a", "armeabi-v7a"];
+
+    const androidVersion = randomChoice(androidVersions);
+    const device = randomChoice(devices);
+    const buildId = randomBuildId();
+    const resolution = randomResolution();
+    const fbav = randomFbav();
+    const fbbv = randomInt(320000000, 520000000);
+    const arch = `${randomChoice(archs)}:${randomChoice(archs)}`;
+    const selectedLocale = randomChoice(locales);
+    const selectedCarrier = randomChoice(carriers);
+
+    const userAgent = `Dalvik/2.1.0 (Linux; U; Android ${androidVersion}; ${device.model} Build/${buildId}) ` +
+        `[FBAN/Orca-Android;FBAV/${fbav};FBPN/com.facebook.orca;` +
+        `FBLC/${selectedLocale};FBBV/${fbbv};FBCR/${selectedCarrier};` +
+        `FBMF/${device.brand};FBBD/${device.brand};FBDV/${device.model};` +
+        `FBSV/${androidVersion};FBCA/${arch};` +
+        `FBDM/{density=${resolution.density.toFixed(1)},width=${resolution.width},height=${resolution.height}};` +
+        `FB_FW/1;]`;
+
+    return {
+        userAgent,
+        androidVersion,
+        device,
+        buildId,
+        resolution,
+        fbav,
+        fbbv,
+        locale: selectedLocale,
+        carrier: selectedCarrier
+    };
+}
+
+function generateUserAgentByPersona(persona = 'desktop', options = {}) {
+    if (persona === 'android' || persona === 'mobile') {
+        if (options.cachedAndroidUA && options.cachedAndroidDevice) {
+            return {
+                userAgent: options.cachedAndroidUA,
+                androidVersion: options.cachedAndroidVersion,
+                device: options.cachedAndroidDevice,
+                buildId: options.cachedAndroidBuildId,
+                resolution: options.cachedAndroidResolution,
+                fbav: options.cachedAndroidFbav,
+                fbbv: options.cachedAndroidFbbv,
+                locale: options.cachedAndroidLocale,
+                carrier: options.cachedAndroidCarrier,
+                persona: 'android'
+            };
+        }
+
+        const androidData = randomOrcaUA();
+        return {
+            ...androidData,
+            persona: 'android'
+        };
+    }
+
+    if (options.cachedUserAgent && options.cachedSecChUa) {
+        return {
+            userAgent: options.cachedUserAgent,
+            secChUa: options.cachedSecChUa,
+            secChUaFullVersionList: options.cachedSecChUaFullVersionList,
+            secChUaPlatform: options.cachedSecChUaPlatform,
+            secChUaPlatformVersion: options.cachedSecChUaPlatformVersion,
+            browser: options.cachedBrowser || 'Google Chrome',
+            persona: 'desktop'
+        };
+    }
+
+    const desktopData = randomUserAgent();
+    return {
+        ...desktopData,
+        persona: 'desktop'
+    };
+}
+
+function cachePersonaData(options, personaData) {
+    if (personaData.persona === 'android') {
+        options.cachedAndroidUA = personaData.userAgent;
+        options.cachedAndroidVersion = personaData.androidVersion;
+        options.cachedAndroidDevice = personaData.device;
+        options.cachedAndroidBuildId = personaData.buildId;
+        options.cachedAndroidResolution = personaData.resolution;
+        options.cachedAndroidFbav = personaData.fbav;
+        options.cachedAndroidFbbv = personaData.fbbv;
+        options.cachedAndroidLocale = personaData.locale;
+        options.cachedAndroidCarrier = personaData.carrier;
+    } else {
+        options.cachedUserAgent = personaData.userAgent;
+        options.cachedSecChUa = personaData.secChUa;
+        options.cachedSecChUaFullVersionList = personaData.secChUaFullVersionList;
+        options.cachedSecChUaPlatform = personaData.secChUaPlatform;
+        options.cachedSecChUaPlatformVersion = personaData.secChUaPlatformVersion;
+        options.cachedBrowser = personaData.browser;
+    }
+    return options;
+}
+
+module.exports = {
+    defaultUserAgent,
+    windowsUserAgent: defaultUserAgent,
+    randomUserAgent,
+    randomBuildId,
+    randomResolution,
+    randomFbav,
+    randomOrcaUA,
+    generateUserAgentByPersona,
+    cachePersonaData,
+};

package/src/utils/validation.js

@@ -0,0 +1,157 @@
+"use strict";
+
+/**
+ * Input validation and sanitization utilities
+ */
+
+class InputValidator {
+  constructor() {
+    this.maxMessageLength = 10000;
+    this.maxThreadNameLength = 255;
+    this.maxNicknameLength = 50;
+  }
+
+  /**
+   * Validate thread ID
+   * @param {string|number} threadID
+   * @returns {boolean}
+   */
+  isValidThreadID(threadID) {
+    if (!threadID) return false;
+    const id = String(threadID).trim();
+    // Thread IDs are numeric, can be up to 20 digits
+    return /^\d{1,20}$/.test(id);
+  }
+
+  /**
+   * Validate user ID
+   * @param {string|number} userID
+   * @returns {boolean}
+   */
+  isValidUserID(userID) {
+    return this.isValidThreadID(userID); // Same format
+  }
+
+  /**
+   * Validate message content
+   * @param {string|object} message
+   * @returns {boolean}
+   */
+  isValidMessage(message) {
+    if (typeof message === 'string') {
+      return message.length > 0 && message.length <= this.maxMessageLength;
+    }
+    if (typeof message === 'object' && message !== null) {
+      return message.body || message.sticker || message.attachment || message.emoji;
+    }
+    return false;
+  }
+
+  /**
+   * Sanitize message content
+   * @param {string} message
+   * @returns {string}
+   */
+  sanitizeMessage(message) {
+    if (typeof message !== 'string') return message;
+    // Remove null bytes and control characters
+    return message.replace(/[\x00-\x1F\x7F]/g, '').trim();
+  }
+
+  /**
+   * Validate and sanitize thread name
+   * @param {string} name
+   * @returns {string|null}
+   */
+  sanitizeThreadName(name) {
+    if (typeof name !== 'string') return null;
+    const sanitized = name.trim();
+    return sanitized.length > 0 && sanitized.length <= this.maxThreadNameLength ? sanitized : null;
+  }
+
+  /**
+   * Validate and sanitize nickname
+   * @param {string} nickname
+   * @returns {string|null}
+   */
+  sanitizeNickname(nickname) {
+    if (typeof nickname !== 'string') return null;
+    const sanitized = nickname.trim();
+    return sanitized.length > 0 && sanitized.length <= this.maxNicknameLength ? sanitized : null;
+  }
+
+  /**
+   * Validate array of IDs
+   * @param {Array} ids
+   * @param {function} validator
+   * @returns {boolean}
+   */
+  validateIDArray(ids, validator = this.isValidThreadID.bind(this)) {
+    if (!Array.isArray(ids)) return false;
+    return ids.length > 0 && ids.length <= 100 && ids.every(validator);
+  }
+
+  /**
+   * Validate email
+   * @param {string} email
+   * @returns {boolean}
+   */
+  isValidEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+  }
+
+  /**
+   * Validate URL
+   * @param {string} url
+   * @returns {boolean}
+   */
+  isValidUrl(url) {
+    try {
+      new URL(url);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Validate file path (basic check)
+   * @param {string} path
+   * @returns {boolean}
+   */
+  isValidFilePath(path) {
+    if (typeof path !== 'string') return false;
+    // Basic check - no null bytes, reasonable length
+    return path.length > 0 && path.length <= 255 && !path.includes('\x00');
+  }
+
+  /**
+   * Validate emoji
+   * @param {string} emoji
+   * @returns {boolean}
+   */
+  isValidEmoji(emoji) {
+    if (typeof emoji !== 'string') return false;
+    // Check if it's an emoji (basic check)
+    return /\p{Emoji}/u.test(emoji) || emoji.length === 1;
+  }
+}
+
+const globalValidator = new InputValidator();
+
+module.exports = {
+  InputValidator,
+  globalValidator,
+  validateThreadID: (id) => globalValidator.isValidThreadID(id),
+  validateUserID: (id) => globalValidator.isValidUserID(id),
+  validateMessage: (msg) => globalValidator.isValidMessage(msg),
+  sanitizeMessage: (msg) => globalValidator.sanitizeMessage(msg),
+  sanitizeThreadName: (name) => globalValidator.sanitizeThreadName(name),
+  sanitizeNickname: (nick) => globalValidator.sanitizeNickname(nick),
+  validateIDArray: (ids, validator) => globalValidator.validateIDArray(ids, validator),
+  isValidEmail: (email) => globalValidator.isValidEmail(email),
+  isValidUrl: (url) => globalValidator.isValidUrl(url),
+  isValidFilePath: (path) => globalValidator.isValidFilePath(path),
+  isValidEmoji: (emoji) => globalValidator.isValidEmoji(emoji)
+};