@tindalabs/shield 0.1.0

package/dist/config/default-extensions-config.json

@@ -0,0 +1,103 @@
+{
+    "extensions": {
+        "evernote-web-clipper": {
+            "name": "Evernote Web Clipper",
+            "description": "Clips web content to Evernote",
+            "risk": "high",
+            "detectionMethods": {
+                "domSelectors": [".evernote-clipper", "#evernoteClipper", "#evernoteClipperToolsMain"],
+                "jsSignatures": ["EvernoteClipper", "ENClipper"]
+            }
+        },
+        "onenote-clipper": {
+            "name": "OneNote Web Clipper",
+            "description": "Clips web content to OneNote",
+            "risk": "high",
+            "detectionMethods": {
+                "domSelectors": [".onenote-clipper", "#oneNoteClipper", "#oneNoteWebClipper"],
+                "jsSignatures": ["OneNoteClipper", "OneNoteWebClipper"]
+            }
+        },
+        "notion-web-clipper": {
+            "name": "Notion Web Clipper",
+            "description": "Clips web content to Notion",
+            "risk": "high",
+            "detectionMethods": {
+                "domSelectors": [".notion-clipper", "#notionClipper"],
+                "jsSignatures": ["notionClientAPI"]
+            }
+        },
+        "pocket": {
+            "name": "Pocket",
+            "description": "Saves content for later reading",
+            "risk": "medium",
+            "detectionMethods": {
+                "domSelectors": [".pocket-button", "#pocket-button-container"],
+                "jsSignatures": ["Pocket", "PocketButtonManager"]
+            }
+        },
+        "instapaper": {
+            "name": "Instapaper",
+            "description": "Saves content for later reading",
+            "risk": "medium",
+            "detectionMethods": {
+                "domSelectors": [".instapaper-button", "#instapaper-button"],
+                "jsSignatures": ["Instapaper"]
+            }
+        },
+        "readwise": {
+            "name": "Readwise",
+            "description": "Saves highlights and annotations",
+            "risk": "medium",
+            "detectionMethods": {
+                "domSelectors": [".readwise-button", "#readwise-highlights"],
+                "jsSignatures": ["readwiseAPI", "readwiseHighlighter"]
+            }
+        },
+        "singlefile": {
+            "name": "SingleFile",
+            "description": "Saves complete web pages",
+            "risk": "high",
+            "detectionMethods": {
+                "domSelectors": [".singlefile-button", "#singlefile-ui"],
+                "jsSignatures": ["singlefile", "SingleFile"]
+            }
+        },
+        "save-page-we": {
+            "name": "Save Page WE",
+            "description": "Saves complete web pages",
+            "risk": "high",
+            "detectionMethods": {
+                "domSelectors": [".save-page-we"],
+                "jsSignatures": ["savePageWE"]
+            }
+        },
+        "fireshot": {
+            "name": "Fireshot",
+            "description": "Takes screenshots of web pages",
+            "risk": "high",
+            "detectionMethods": {
+                "domSelectors": [".fireshot-ui", "#fireshot-container"],
+                "jsSignatures": ["FireShot", "FSCapture"]
+            }
+        },
+        "gofullpage": {
+            "name": "GoFullPage",
+            "description": "Takes full page screenshots",
+            "risk": "high",
+            "detectionMethods": {
+                "domSelectors": [".gofullpage-ui"],
+                "jsSignatures": ["GoFullPage", "FullPageScreenshot"]
+            }
+        },
+        "web-scraper": {
+            "name": "Web Scraper",
+            "description": "Extracts data from web pages",
+            "risk": "high",
+            "detectionMethods": {
+                "domSelectors": [".web-scraper-selection", "#web-scraper-selector-overlay"],
+                "jsSignatures": ["WebScraper", "SelectorGraph"]
+            }
+        }
+    }
+}

package/dist/core/ContentProtector.d.ts

@@ -0,0 +1,63 @@
+import type { ContentProtectionOptions, ProtectionStrategy } from "../types";
+import { LoggableComponent } from "../utils/base/LoggableComponent";
+/**
+ * Main class for protecting content from copying, screenshotting, and other extraction methods
+ * Coordinates multiple protection strategies and manages their lifecycle
+ */
+export declare class ContentProtector extends LoggableComponent {
+    private options;
+    private strategies;
+    private isActive;
+    private overlayManager;
+    private protectedContentManager;
+    private mediator;
+    private handlerRegistry;
+    /**
+     * Create a new ContentProtector instance
+     * @param options Configuration options for content protection
+     */
+    constructor(options?: ContentProtectionOptions);
+    /**
+     * Initialize protection strategies based on configuration options
+     * Creates strategy instances and adds them to the strategies map
+     */
+    private initializeStrategies;
+    /**
+     * Apply all protection strategies
+     * Activates each strategy to protect content
+     */
+    protect(): void;
+    /**
+     * Remove all protection strategies
+     * Deactivates each strategy and cleans up resources
+     */
+    unprotect(): void;
+    /**
+     * Update protection options
+     * Removes existing protection, updates options, and reapplies if needed
+     * @param options New options to apply
+     */
+    updateOptions(options: Partial<ContentProtectionOptions>): void;
+    /**
+     * Check if protection is currently active
+     * @returns True if protection is active
+     */
+    isProtected(): boolean;
+    /**
+     * Get a specific strategy by name
+     * @param name Strategy name
+     * @returns The strategy instance or undefined if not found
+     */
+    getStrategy(name: string): ProtectionStrategy | undefined;
+    /**
+     * Check if a specific strategy is active
+     * @param name Strategy name
+     * @returns True if the strategy exists
+     */
+    hasStrategy(name: string): boolean;
+    /**
+     * Clean up and dispose of all resources
+     * Removes protection and cleans up global managers
+     */
+    dispose(): void;
+}

package/dist/core/ContentProtector.js

@@ -0,0 +1,281 @@
+import { KeyboardStrategy, PrintStrategy, ContextMenuStrategy, WatermarkStrategy, SelectionStrategy, DevToolsStrategy, ScreenshotStrategy, BrowserExtensionDetectionStrategy, FrameEmbeddingProtectionStrategy, } from "../strategies";
+import { ClipboardStrategy } from "../strategies/ClipboardStrategy";
+import { SecurityOverlayManager } from "../utils/securityOverlayManager";
+import { intervalManager } from "../utils/intervalManager";
+import { eventManager } from "../utils/eventManager";
+import { ContentProtectionMediator } from "./mediator/ContentProtectionMediator";
+import { HandlerRegistry } from "./mediator/handlers/eventHandlerRegistry";
+import { ProtectedContentManager } from "../utils/protectedContentManager";
+import { LoggableComponent } from "../utils/base/LoggableComponent";
+/**
+ * Main class for protecting content from copying, screenshotting, and other extraction methods
+ * Coordinates multiple protection strategies and manages their lifecycle
+ */
+export class ContentProtector extends LoggableComponent {
+    /**
+     * Create a new ContentProtector instance
+     * @param options Configuration options for content protection
+     */
+    constructor(options = {}) {
+        // Define default options
+        const defaults = {
+            preventKeyboardShortcuts: true,
+            preventContextMenu: true,
+            preventPrinting: true,
+            preventSelection: true,
+            preventScreenshots: true,
+            enableWatermark: false,
+            preventDevTools: false,
+            preventExtensions: false,
+            preventEmbedding: false,
+            preventClipboard: false,
+            debugMode: false,
+        };
+        // Merge defaults with provided options. We compute this before super()
+        // because super() needs the resolved debugMode flag.
+        const mergedOptions = { ...defaults, ...options };
+        super("ContentProtector", !!mergedOptions.debugMode);
+        this.strategies = new Map();
+        this.isActive = false;
+        this.options = mergedOptions;
+        // Normalize and set targetElement if not provided
+        const resolveTargetElement = (t) => {
+            if (typeof document === "undefined")
+                return null;
+            // Already an element
+            if (t instanceof HTMLElement)
+                return t;
+            // CSS selector string
+            if (typeof t === "string") {
+                try {
+                    const el = document.querySelector(t);
+                    return el instanceof HTMLElement ? el : null;
+                }
+                catch {
+                    return null;
+                }
+            }
+            // Vue 3 ref ({ value: HTMLElement }) or Vue component ($el) or DOM-like node
+            if (t && typeof t === "object") {
+                const maybe = t;
+                if (maybe.value instanceof HTMLElement)
+                    return maybe.value;
+                if (maybe.$el instanceof HTMLElement)
+                    return maybe.$el;
+                if (maybe.nodeType === 1 && typeof maybe.nodeName === "string")
+                    return t;
+            }
+            return null;
+        };
+        // Normalize provided targetElement, or default to document.body
+        const normalizedTarget = resolveTargetElement(this.options.targetElement);
+        if (normalizedTarget) {
+            this.options.targetElement = normalizedTarget;
+        }
+        else if (!this.options.targetElement && typeof document !== "undefined") {
+            this.options.targetElement = document.body;
+        }
+        else {
+            // If user provided something invalid, clear it to avoid passing non-DOM objects to strategies
+            if (this.options.targetElement) {
+                this.warn("Provided targetElement is not a DOM element - falling back to document.body if available");
+                if (typeof document !== "undefined")
+                    this.options.targetElement = document.body;
+                else
+                    this.options.targetElement = undefined;
+            }
+        }
+        // Initialize the mediator
+        this.mediator = new ContentProtectionMediator(this.options.debugMode);
+        // Initialize the handler registry
+        this.handlerRegistry = new HandlerRegistry(this.mediator, this.options.debugMode);
+        // Initialize overlay manager
+        this.overlayManager = new SecurityOverlayManager(this.options.debugMode);
+        this.overlayManager.setMediator(this.mediator);
+        // Initialize protected content manager
+        this.protectedContentManager = new ProtectedContentManager(this.options.targetElement, this.options.debugMode);
+        this.protectedContentManager.setMediator(this.mediator);
+        // Wire content visibility callbacks from customHandlers (useful for Vue re-mounting)
+        if (this.options.customHandlers) {
+            this.protectedContentManager.setContentCallbacks(this.options.customHandlers.onContentHidden, this.options.customHandlers.onContentRestored);
+        }
+        // Configure debug mode for managers
+        if (this.options.debugMode) {
+            this.logger.log("Initialized with options", this.options);
+            // Enable debug mode for the event manager
+            eventManager.setDebugMode(true);
+            // Enable debug mode for the interval manager
+            //intervalManager.setDebugMode(true);
+        }
+        this.initializeStrategies();
+    }
+    /**
+     * Initialize protection strategies based on configuration options
+     * Creates strategy instances and adds them to the strategies map
+     */
+    initializeStrategies() {
+        const { debugMode, targetElement, customHandlers } = this.options;
+        // Initialize strategies based on options
+        if (this.options.preventKeyboardShortcuts) {
+            this.strategies.set("keyboard", new KeyboardStrategy(customHandlers?.onKeyboardShortcutBlocked, debugMode));
+        }
+        if (this.options.preventContextMenu) {
+            this.strategies.set("contextMenu", new ContextMenuStrategy(this.options.contextMenuOptions, targetElement, customHandlers?.onContextMenuAttempt, debugMode));
+        }
+        if (this.options.preventPrinting) {
+            this.strategies.set("print", new PrintStrategy(customHandlers?.onPrintAttempt, debugMode));
+        }
+        if (this.options.preventSelection) {
+            this.strategies.set("selection", new SelectionStrategy(targetElement, customHandlers?.onSelectionAttempt, debugMode));
+        }
+        if (this.options.enableWatermark && this.options.watermarkOptions) {
+            this.strategies.set("watermark", new WatermarkStrategy(this.options.watermarkOptions, targetElement, debugMode));
+        }
+        if (this.options.preventDevTools) {
+            const devToolsStrategy = new DevToolsStrategy(this.options.devToolsOptions, targetElement, customHandlers?.onDevToolsOpen, debugMode);
+            devToolsStrategy.setMediator(this.mediator);
+            this.strategies.set("devTools", devToolsStrategy);
+        }
+        if (this.options.preventScreenshots) {
+            const screenshotStrategy = new ScreenshotStrategy(this.options.screenshotOptions, targetElement, customHandlers?.onScreenshotAttempt, debugMode);
+            screenshotStrategy.setMediator(this.mediator);
+            this.strategies.set("screenshot", screenshotStrategy);
+        }
+        if (this.options.preventExtensions) {
+            const extensionStrategy = new BrowserExtensionDetectionStrategy(this.options.extensionOptions, targetElement, customHandlers?.onExtensionDetected, debugMode);
+            extensionStrategy.setMediator(this.mediator);
+            this.strategies.set("extension", extensionStrategy);
+        }
+        if (this.options.preventEmbedding) {
+            const frameStrategy = new FrameEmbeddingProtectionStrategy(this.options.frameEmbeddingOptions, targetElement, customHandlers?.onFrameEmbeddingDetected, debugMode);
+            frameStrategy.setMediator(this.mediator);
+            this.strategies.set("iFrame", frameStrategy);
+        }
+        if (this.options.preventClipboard) {
+            this.strategies.set("clipboard", new ClipboardStrategy(this.options.clipboardOptions, targetElement, customHandlers?.onClipboardAttempt, debugMode));
+        }
+        this.logger.log("Initialized strategies", Array.from(this.strategies.keys()));
+    }
+    /**
+     * Apply all protection strategies
+     * Activates each strategy to protect content
+     */
+    protect() {
+        if (this.isActive) {
+            this.logger.log("Already protected, skipping");
+            return;
+        }
+        this.logger.log("Applying protection strategies");
+        // Apply each strategy
+        for (const [name, strategy] of this.strategies.entries()) {
+            try {
+                this.logger.log(`Applying strategy "${name}"`);
+                strategy.apply();
+            }
+            catch (error) {
+                this.logger.error(`Error applying strategy "${name}":`, error);
+            }
+        }
+        this.isActive = true;
+        this.logger.log("All protection strategies applied successfully");
+    }
+    /**
+     * Remove all protection strategies
+     * Deactivates each strategy and cleans up resources
+     */
+    unprotect() {
+        if (!this.isActive) {
+            this.logger.log("Not protected, skipping");
+            return;
+        }
+        this.logger.log("Removing protection strategies");
+        // Create a copy of the strategy entries to avoid modification during iteration
+        const entries = Array.from(this.strategies.entries());
+        // Remove each strategy and track failures
+        let successCount = 0;
+        let failCount = 0;
+        for (const [name, strategy] of entries) {
+            try {
+                this.logger.log(`Removing strategy "${name}"`);
+                if (strategy.isApplied()) {
+                    strategy.remove();
+                    successCount++;
+                }
+            }
+            catch (error) {
+                failCount++;
+                this.logger.error(`Error removing strategy "${name}":`, error);
+            }
+        }
+        // Clear all strategies regardless of removal success
+        this.strategies.clear();
+        this.isActive = false;
+        this.logger.log(`Protection removed (${successCount} successful, ${failCount} failed)`);
+    }
+    /**
+     * Update protection options
+     * Removes existing protection, updates options, and reapplies if needed
+     * @param options New options to apply
+     */
+    updateOptions(options) {
+        this.logger.log("Updating options", options);
+        // Store the current state
+        const wasActive = this.isActive;
+        // Remove existing protections
+        this.unprotect();
+        // Update options
+        this.options = {
+            ...this.options,
+            ...options,
+        };
+        // Update debug mode for managers and logger
+        if (options.debugMode !== undefined) {
+            this.logger.setDebugMode(options.debugMode);
+            eventManager.setDebugMode(options.debugMode);
+            //intervalManager.setDebugMode(options.debugMode);
+            this.overlayManager.setDebugMode(options.debugMode);
+        }
+        this.logger.log("New options after update", this.options);
+        // Reinitialize strategies
+        this.strategies.clear();
+        this.initializeStrategies();
+        // Reapply protection if it was active before
+        if (wasActive) {
+            this.logger.log("Reapplying protection after options update");
+            this.protect();
+        }
+    }
+    /**
+     * Check if protection is currently active
+     * @returns True if protection is active
+     */
+    isProtected() {
+        return this.isActive;
+    }
+    /**
+     * Get a specific strategy by name
+     * @param name Strategy name
+     * @returns The strategy instance or undefined if not found
+     */
+    getStrategy(name) {
+        return this.strategies.get(name);
+    }
+    /**
+     * Check if a specific strategy is active
+     * @param name Strategy name
+     * @returns True if the strategy exists
+     */
+    hasStrategy(name) {
+        return this.strategies.has(name);
+    }
+    /**
+     * Clean up and dispose of all resources
+     * Removes protection and cleans up global managers
+     */
+    dispose() {
+        this.unprotect();
+        // Dispose interval manager
+        intervalManager.dispose();
+        this.logger.log("Disposed all resources");
+    }
+}

package/dist/core/index.d.ts

@@ -0,0 +1 @@
+export { ContentProtector } from './ContentProtector';

package/dist/core/index.js

@@ -0,0 +1,2 @@
+// BARREL FILE
+export { ContentProtector } from './ContentProtector';

package/dist/core/mediator/ContentProtectionMediator.d.ts

@@ -0,0 +1,86 @@
+import { ProtectionEvent, ProtectionEventType } from './protection-event';
+import { ProtectionEventHandler, ProtectionMediator, Subscription, SubscriptionOptions } from './types';
+/**
+ * Mediator for coordinating communication between protection strategies
+ * Implements the mediator pattern to decouple strategies and enable event-based communication
+ */
+export declare class ContentProtectionMediator implements ProtectionMediator {
+    private subscriptions;
+    private subscriptionCounter;
+    private debugMode;
+    private eventHistory;
+    private readonly MAX_HISTORY_SIZE;
+    /**
+     * Create a new ContentProtectionMediator
+     * @param debugMode Enable debug mode for detailed logging
+     */
+    constructor(debugMode?: boolean);
+    /**
+     * Subscribe to an event
+     * @param eventType Type of event to subscribe to
+     * @param handler Handler function for the event
+     * @param options Optional subscription options
+     * @returns Subscription ID for later unsubscribing
+     */
+    subscribe(eventType: ProtectionEventType, handler: ProtectionEventHandler, options?: SubscriptionOptions): string;
+    /**
+     * Unsubscribe from an event
+     * @param subscriptionId ID of the subscription to remove
+     * @returns True if the subscription was found and removed
+     */
+    unsubscribe(subscriptionId: string): boolean;
+    /**
+     * Unsubscribe all handlers with a specific context
+     * @param context Context to unsubscribe (e.g., strategy name)
+     * @returns Number of subscriptions removed
+     */
+    unsubscribeByContext(context: string): number;
+    /**
+     * Publish an event to all subscribers
+     * @param event Event to publish
+     */
+    publish(event: ProtectionEvent): void;
+    /**
+     * Get all subscriptions for a specific event type
+     * @param eventType Type of event to get subscriptions for
+     * @returns Array of subscriptions
+     */
+    getSubscriptions(eventType: ProtectionEventType): Subscription[];
+    /**
+     * Get all subscriptions
+     * @returns Map of event types to subscriptions
+     */
+    getAllSubscriptions(): Map<ProtectionEventType, Subscription[]>;
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+    /**
+     * Get debug information about the mediator
+     * @returns Object with debug information
+     */
+    getDebugInfo(): {
+        subscriptionCount: number;
+        eventTypeCount: number;
+        eventTypes: string[];
+        recentEvents: ProtectionEvent[];
+    };
+    /**
+     * Add an event to the history
+     * @param event Event to add
+     */
+    private addToEventHistory;
+    /**
+     * Clear all subscriptions
+     * @returns Number of subscriptions cleared
+     */
+    clearAllSubscriptions(): number;
+    /**
+     * Helper method to create and publish an event
+     * @param type Event type
+     * @param source Source of the event
+     * @param data Additional data
+     */
+    createAndPublishEvent(type: ProtectionEventType, source: string, data?: unknown): void;
+}