@tindalabs/shield 0.1.0

package/dist/utils/detectors/AbstractDevToolsDetector.js

@@ -0,0 +1,127 @@
+import { LoggableComponent } from "../base/LoggableComponent";
+/**
+ * Enum representing different types of errors that can occur in detectors
+ */
+export var DetectorErrorType;
+(function (DetectorErrorType) {
+    /**
+     * Error during initialization of a detector
+     */
+    DetectorErrorType["INITIALIZATION_ERROR"] = "initialization_error";
+    /**
+     * Error during detection check
+     */
+    DetectorErrorType["DETECTION_ERROR"] = "detection_error";
+    /**
+     * Error related to browser compatibility
+     */
+    DetectorErrorType["COMPATIBILITY_ERROR"] = "compatibility_error";
+    /**
+     * Error during cleanup/disposal
+     */
+    DetectorErrorType["DISPOSAL_ERROR"] = "disposal_error";
+    /**
+     * Error in worker communication
+     */
+    DetectorErrorType["WORKER_ERROR"] = "worker_error";
+    /**
+     * Error in DOM manipulation
+     */
+    DetectorErrorType["DOM_ERROR"] = "dom_error";
+    /**
+     * Error in event handling
+     */
+    DetectorErrorType["EVENT_ERROR"] = "event_error";
+    /**
+     * Unexpected or unknown error
+     */
+    DetectorErrorType["UNKNOWN_ERROR"] = "unknown_error";
+})(DetectorErrorType || (DetectorErrorType = {}));
+/**
+ * Abstract base class for DevTools detectors
+ * Implements common functionality to reduce duplication across detector implementations
+ */
+export class AbstractDevToolsDetector extends LoggableComponent {
+    /**
+     * Create a new detector instance
+     * @param detectorName Name of the detector for logging
+     * @param options Configuration options
+     */
+    constructor(detectorName, options = {}) {
+        super(detectorName, !!options.debugMode);
+        this.detectorName = detectorName;
+        this.isDevToolsOpen = false;
+        this.isChecking = false;
+        this.onDevToolsChange = options.onDevToolsChange || (() => { });
+        this.logger.log("Initialized");
+    }
+    /**
+     * Get the current DevTools state
+     * @returns True if DevTools is open
+     */
+    isOpen() {
+        return this.isDevToolsOpen;
+    }
+    /**
+     * Update the DevTools state and notify listeners if changed
+     * @param isOpen New DevTools state
+     */
+    updateDevToolsState(isOpen) {
+        // Only trigger callback if state changed
+        if (isOpen !== this.isDevToolsOpen) {
+            this.isDevToolsOpen = isOpen;
+            this.onDevToolsChange(isOpen);
+            this.logger.log(`DevTools ${isOpen ? "opened" : "closed"}`);
+        }
+    }
+    /**
+     * Handle an error with appropriate logging
+     * @param errorType Type of error that occurred
+     * @param message Error message
+     * @param error The error object
+     */
+    handleError(errorType, message, error) {
+        this.logger.error(`[${errorType}] ${message}:`, error);
+        // Additional error handling logic can be added here
+        // For example, reporting errors to a monitoring service
+    }
+    /**
+     * Execute a function with error handling
+     * @param operation Name of the operation for error reporting
+     * @param errorType Type of error to report if the operation fails
+     * @param fn Function to execute
+     * @returns The result of the function or undefined if an error occurred
+     */
+    safeExecute(operation, errorType, fn) {
+        try {
+            return fn();
+        }
+        catch (error) {
+            this.handleError(errorType, `Error during ${operation}`, error);
+            return undefined;
+        }
+    }
+    /**
+     * Execute an async function with error handling
+     * @param operation Name of the operation for error reporting
+     * @param errorType Type of error to report if the operation fails
+     * @param fn Async function to execute
+     * @returns Promise resolving to the result of the function or undefined if an error occurred
+     */
+    async safeExecuteAsync(operation, errorType, fn) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            this.handleError(errorType, `Error during ${operation}`, error);
+            return undefined;
+        }
+    }
+    /**
+     * Clean up resources
+     * Override in subclasses to perform detector-specific cleanup
+     */
+    dispose() {
+        this.logger.log("Disposed");
+    }
+}

package/dist/utils/detectors/dateToStringDetector.d.ts

@@ -0,0 +1,43 @@
+import { AbstractDevToolsDetector } from "./AbstractDevToolsDetector";
+import { DevToolsDetectorOptions } from "./detectorInterface";
+/**
+ * Options for the DateToStringDetector
+ */
+export interface DateToStringDetectorOptions extends DevToolsDetectorOptions {
+    /**
+     * Threshold for detection (number of toString calls)
+     */
+    threshold?: number;
+}
+/**
+ * Utility class for detecting DevTools using Date.toString behavior
+ * This approach works by detecting multiple calls to toString when an object is logged
+ * and DevTools is open
+ */
+export declare class DateToStringDetector extends AbstractDevToolsDetector {
+    private date;
+    private count;
+    private threshold;
+    /**
+     * Create a new DateToStringDetector
+     * @param options Configuration options
+     */
+    constructor(options?: DateToStringDetectorOptions);
+    /**
+     * Initialize the date object with custom toString method
+     */
+    private initDateObject;
+    /**
+     * Check if DevTools is open using Date.toString behavior
+     */
+    checkDevTools(): void;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+    /**
+     * Check if this detector is supported in the current browser
+     * @returns True if supported
+     */
+    static isSupported(): boolean;
+}

package/dist/utils/detectors/dateToStringDetector.js

@@ -0,0 +1,96 @@
+import { isBrowser, getBrowser, isMobile } from "../environment";
+import { AbstractDevToolsDetector, DetectorErrorType } from "./AbstractDevToolsDetector";
+/**
+ * Utility class for detecting DevTools using Date.toString behavior
+ * This approach works by detecting multiple calls to toString when an object is logged
+ * and DevTools is open
+ */
+export class DateToStringDetector extends AbstractDevToolsDetector {
+    /**
+     * Create a new DateToStringDetector
+     * @param options Configuration options
+     */
+    constructor(options = {}) {
+        super("DateToStringDetector", options);
+        this.date = null;
+        this.count = 0;
+        this.debugMode = !!options.debugMode;
+        this.onDevToolsChange = options.onDevToolsChange || (() => { });
+        this.threshold = options.threshold || 2;
+        // Initialize the date object with custom toString
+        this.initDateObject();
+        this.logger.log("Initialized with threshold:", this.threshold);
+    }
+    /**
+     * Initialize the date object with custom toString method
+     */
+    initDateObject() {
+        this.safeExecute("initDateObject", DetectorErrorType.INITIALIZATION_ERROR, () => {
+            if (!isBrowser())
+                return;
+            this.date = new Date();
+            // Override toString to count calls
+            this.date.toString = () => {
+                this.count++;
+                // Use a hidden property to avoid infinite recursion when logging
+                const originalDate = this.date ? new Date(this.date.getTime()) : new Date();
+                this.logger.log(`toString() called (${this.count} times)`, originalDate.toISOString());
+                return "";
+            };
+            this.logger.log("Date object initialized");
+        });
+    }
+    /**
+     * Check if DevTools is open using Date.toString behavior
+     */
+    checkDevTools() {
+        if (this.isChecking || !isBrowser())
+            return;
+        this.isChecking = true;
+        this.safeExecute("checkDevTools", DetectorErrorType.DETECTION_ERROR, () => {
+            // Reset counter
+            this.count = 0;
+            // Log the date object - this will trigger toString
+            console.log(this.date);
+            // Clear console to avoid clutter
+            if (!this.debugMode) {
+                console.clear();
+            }
+            // If toString was called multiple times, DevTools is likely open
+            const isOpen = this.count >= this.threshold;
+            // Update state and notify listeners if changed
+            this.updateDevToolsState(isOpen);
+            this.logger.log(`toString called ${this.count} times, threshold: ${this.threshold}`);
+            this.isChecking = false;
+        });
+        // Ensure isChecking is reset even if an error occurs
+        if (this.isChecking) {
+            this.isChecking = false;
+        }
+    }
+    /**
+     * Clean up resources
+     */
+    dispose() {
+        this.safeExecute("dispose", DetectorErrorType.DISPOSAL_ERROR, () => {
+            this.date = null;
+            this.logger.log("Disposed");
+        });
+        super.dispose();
+    }
+    /**
+     * Check if this detector is supported in the current browser
+     * @returns True if supported
+     */
+    static isSupported() {
+        if (!isBrowser())
+            return false;
+        const browser = getBrowser();
+        const isMobileDevice = isMobile();
+        // Not supported in iOS Chrome or iOS Edge
+        if (isMobileDevice && (browser.name === "chrome" || browser.name === "edge")) {
+            return false;
+        }
+        return true;
+    }
+}

package/dist/utils/detectors/debugLibDetector.d.ts

@@ -0,0 +1,64 @@
+import { AbstractDevToolsDetector } from "./AbstractDevToolsDetector";
+import { DevToolsDetectorOptions } from "./detectorInterface";
+/**
+ * Options for the DebugLibDetector
+ */
+export interface DebugLibDetectorOptions extends DevToolsDetectorOptions {
+    /**
+     * Check interval in milliseconds
+     */
+    checkInterval?: number;
+    /**
+     * Additional libraries to check for beyond the default ones
+     * Format: { name: string, globalVar: string }
+     */
+    additionalLibraries?: Array<{
+        name: string;
+        globalVar: string;
+    }>;
+}
+/**
+ * Detector that checks for third-party debugging libraries like Eruda and vConsole
+ */
+export declare class DebugLibDetector extends AbstractDevToolsDetector {
+    private checkInterval;
+    private taskId;
+    private libraries;
+    private static readonly DEFAULT_LIBRARIES;
+    /**
+     * Create a new DebugLibDetector
+     * @param options Configuration options
+     */
+    constructor(options?: DebugLibDetectorOptions);
+    /**
+     * Start continuous detection
+     */
+    startDetection(): void;
+    /**
+     * Stop continuous detection
+     */
+    stopDetection(): void;
+    /**
+     * Check if any debug libraries are present in the global scope
+     */
+    checkDevTools(): void;
+    /**
+     * Detect which debug libraries are present
+     * @returns Array of detected library names
+     */
+    private detectDebugLibraries;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+    /**
+     * Static utility to check if any debug libraries are present
+     * @returns True if any debug library is detected
+     */
+    static isAnyDebugLibPresent(): boolean;
+    /**
+     * Check if this detector is supported in the current browser
+     * @returns True if supported
+     */
+    static isSupported(): boolean;
+}

package/dist/utils/detectors/debugLibDetector.js

@@ -0,0 +1,195 @@
+import { isBrowser } from "../environment";
+import { intervalManager } from "../intervalManager";
+import { AbstractDevToolsDetector, DetectorErrorType } from "./AbstractDevToolsDetector";
+/**
+ * Detector that checks for third-party debugging libraries like Eruda and vConsole
+ */
+export class DebugLibDetector extends AbstractDevToolsDetector {
+    /**
+     * Create a new DebugLibDetector
+     * @param options Configuration options
+     */
+    constructor(options = {}) {
+        super("DebugLibDetector", options);
+        this.taskId = null;
+        this.checkInterval = options.checkInterval || 1000;
+        // Combine default libraries with any additional ones
+        this.libraries = [...DebugLibDetector.DEFAULT_LIBRARIES];
+        if (options.additionalLibraries && Array.isArray(options.additionalLibraries)) {
+            this.libraries = [...this.libraries, ...options.additionalLibraries];
+        }
+        this.logger.log("Initialized with interval:", this.checkInterval);
+        this.logger.log("Monitoring libraries:", this.libraries.map((lib) => lib.name).join(", "));
+    }
+    /**
+     * Start continuous detection
+     */
+    startDetection() {
+        return this.safeExecute("startDetection", DetectorErrorType.INITIALIZATION_ERROR, () => {
+            if (this.taskId || !isBrowser())
+                return;
+            // Register with IntervalManager for periodic checks
+            this.taskId = intervalManager.registerTask("debug-lib-detection", () => {
+                this.checkDevTools();
+            }, this.checkInterval);
+            this.logger.log(`Started continuous detection with task ID ${this.taskId}`);
+            // Perform initial check
+            this.checkDevTools();
+        });
+    }
+    /**
+     * Stop continuous detection
+     */
+    stopDetection() {
+        return this.safeExecute("stopDetection", DetectorErrorType.DISPOSAL_ERROR, () => {
+            if (!this.taskId)
+                return;
+            // Unregister from IntervalManager
+            intervalManager.unregisterTask(this.taskId);
+            this.taskId = null;
+            this.logger.log("Stopped continuous detection");
+        });
+    }
+    /**
+     * Check if any debug libraries are present in the global scope
+     */
+    checkDevTools() {
+        if (this.isChecking || !isBrowser())
+            return;
+        this.isChecking = true;
+        this.safeExecute("checkDevTools", DetectorErrorType.DETECTION_ERROR, () => {
+            // Check for any debug libraries
+            const detectedLibraries = this.detectDebugLibraries();
+            const isOpen = detectedLibraries.length > 0;
+            if (isOpen) {
+                this.logger.log(`Debug libraries detected: ${detectedLibraries.join(", ")}`);
+            }
+            else {
+                this.logger.log("No debug libraries detected");
+            }
+            // Update state and notify listeners if changed
+            this.updateDevToolsState(isOpen);
+            this.isChecking = false;
+        });
+        // Ensure isChecking is reset even if an error occurs
+        if (this.isChecking) {
+            this.isChecking = false;
+        }
+    }
+    /**
+     * Detect which debug libraries are present
+     * @returns Array of detected library names
+     */
+    detectDebugLibraries() {
+        return (this.safeExecute("detectDebugLibraries", DetectorErrorType.DETECTION_ERROR, () => {
+            const detected = [];
+            for (const lib of this.libraries) {
+                try {
+                    // Check if the global variable exists
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    if (typeof window[lib.globalVar] !== "undefined") {
+                        detected.push(lib.name);
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                }
+                catch (e) {
+                    // Ignore errors in property access
+                }
+            }
+            return detected;
+        }) || []);
+    }
+    /**
+     * Clean up resources
+     */
+    dispose() {
+        this.safeExecute("dispose", DetectorErrorType.DISPOSAL_ERROR, () => {
+            this.stopDetection();
+            this.logger.log("Disposed");
+        });
+        super.dispose();
+    }
+    /**
+     * Static utility to check if any debug libraries are present
+     * @returns True if any debug library is detected
+     */
+    static isAnyDebugLibPresent() {
+        if (!isBrowser())
+            return false;
+        try {
+            for (const lib of DebugLibDetector.DEFAULT_LIBRARIES) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                if (typeof window[lib.globalVar] !== "undefined") {
+                    return true;
+                }
+            }
+            return false;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Check if this detector is supported in the current browser
+     * @returns True if supported
+     */
+    static isSupported() {
+        if (!isBrowser())
+            return false;
+        // This detector works in all browser environments
+        // It's especially useful for mobile browsers where other detectors might be less reliable
+        // It detects third-party debugging libraries and tools that might be injected
+        // No specific browser feature requirements beyond basic JS environment
+        // The detector primarily checks for global objects and properties
+        // Check if we can access the window object and its properties
+        try {
+            // Basic check to ensure we can access window properties
+            if (typeof window === "undefined" || typeof window.navigator === "undefined") {
+                return false;
+            }
+            return true;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (error) {
+            // If we can't access window properties (e.g., in a restricted environment)
+            return false;
+        }
+    }
+}
+// Default libraries to check for
+DebugLibDetector.DEFAULT_LIBRARIES = [
+    // Mobile debugging tools
+    { name: "Eruda", globalVar: "eruda" },
+    { name: "vConsole", globalVar: "VConsole" },
+    { name: "Weinre", globalVar: "weinre" },
+    { name: "Firebug Lite", globalVar: "firebug" },
+    { name: "Console Plus", globalVar: "ConsolePanel" },
+    // Emulators and virtualization platforms
+    { name: "BlueStacks", globalVar: "BlueStacks" },
+    { name: "BlueStacks Helper", globalVar: "BlueStacksGamepad" },
+    { name: "NoxPlayer", globalVar: "NoxPlayer" },
+    { name: "MEmu", globalVar: "MEmu" },
+    { name: "LDPlayer", globalVar: "LDPlayer" },
+    // Remote debugging tools
+    { name: "Vorlon", globalVar: "VORLON" },
+    { name: "GapDebug", globalVar: "GapDebug" },
+    { name: "Bugsnag", globalVar: "Bugsnag" },
+    { name: "LogRocket", globalVar: "LogRocket" },
+    { name: "Sentry", globalVar: "Sentry" },
+    // Framework-specific DevTools
+    { name: "React DevTools", globalVar: "__REACT_DEVTOOLS_GLOBAL_HOOK__" },
+    { name: "Redux DevTools", globalVar: "__REDUX_DEVTOOLS_EXTENSION__" },
+    { name: "Vue DevTools", globalVar: "__VUE_DEVTOOLS_GLOBAL_HOOK__" },
+    { name: "Angular DevTools", globalVar: "ng" },
+    { name: "Ember Inspector", globalVar: "EmberInspector" },
+    // Mobile app debugging
+    { name: "Flipper", globalVar: "__FLIPPER__" },
+    { name: "Reactotron", globalVar: "reactotronClient" },
+    { name: "Apollo DevTools", globalVar: "__APOLLO_DEVTOOLS_GLOBAL_HOOK__" },
+    { name: "Cypress", globalVar: "Cypress" },
+    // Web proxies and network tools
+    { name: "Fiddler", globalVar: "Fiddler" },
+    { name: "Charles", globalVar: "Charles" },
+    { name: "Proxyman", globalVar: "Proxyman" },
+];

package/dist/utils/detectors/debuggerDetector.d.ts

@@ -0,0 +1,51 @@
+import { AbstractDevToolsDetector } from "./AbstractDevToolsDetector";
+import type { DevToolsDetectorOptions } from "./detectorInterface";
+/**
+ * Utility class for detecting DevTools using a Web Worker
+ * This approach works across browsers and provides immediate feedback
+ */
+export interface DebuggerDetectorOptions extends DevToolsDetectorOptions {
+    /**
+     * Timeout duration in milliseconds
+     * If the worker doesn't respond within this time, DevTools is considered open
+     */
+    timeoutDuration?: number;
+}
+export declare class DebuggerDetector extends AbstractDevToolsDetector {
+    private worker;
+    private timeoutId;
+    private timeoutDuration;
+    private isInitialized;
+    private initializationAttempts;
+    private maxInitAttempts;
+    /**
+     * Create a new DebuggerDetector
+     * @param options Configuration options
+     */
+    constructor(options?: DebuggerDetectorOptions);
+    /**
+     * Initialize the worker for DevTools detection
+     */
+    private initWorker;
+    /**
+     * Perform a test check to ensure the worker is functioning correctly
+     */
+    private performTestCheck;
+    /**
+     * Check if DevTools is open
+     */
+    checkDevTools(): void;
+    /**
+     * Terminate the worker and clean up resources
+     */
+    private terminateWorker;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+    /**
+     * Check if this detector is supported in the current browser
+     * @returns True if supported
+     */
+    static isSupported(): boolean;
+}