@rimori/client 1.1.10 → 1.3.0

package/dist/plugin/Logger.d.ts

@@ -0,0 +1,68 @@
+import { RimoriClient } from './RimoriClient';
+/**
+ * Singleton Logger class for Rimori client plugins.
+ * Handles all logging levels, production filtering, and log transmission to Rimori.
+ * Overrides console methods globally for seamless integration.
+ */
+export declare class Logger {
+    private static instance;
+    private isProduction;
+    private logs;
+    private logIdCounter;
+    private originalConsole;
+    private mousePosition;
+    private constructor();
+    /**
+     * Initialize the Logger singleton and override console methods globally.
+     * @param rimori - Rimori client instance
+     * @param isProduction - Whether the environment is production
+     * @returns Logger instance
+     */
+    static getInstance(rimori: RimoriClient, isProduction?: boolean): Logger;
+    private validateIsProduction;
+    /**
+     * Expose log access to global scope for DevTools console access.
+     */
+    private exposeToDevTools;
+    /**
+     * Set up navigation event listeners to clear logs on page changes.
+     */
+    private setupNavigationClearing;
+    /**
+     * Override console methods globally to capture all console calls.
+     */
+    private overrideConsoleMethods;
+    /**
+     * Track mouse position for screenshot context.
+     */
+    private trackMousePosition;
+    /**
+     * Handle console method calls and create log entries.
+     * @param level - Log level
+     * @param args - Console arguments
+     */
+    private handleConsoleCall;
+    /**
+     * Get browser and system information for debugging.
+     * @returns Object with browser and system information
+     */
+    private getBrowserInfo;
+    /**
+     * Capture a screenshot of the current page.
+     * @returns Promise resolving to base64 screenshot or null if failed
+     */
+    private captureScreenshot;
+    /**
+     * Create a log entry with context information.
+     * @param level - Log level
+     * @param message - Log message
+     * @param data - Additional data
+     * @returns Log entry
+     */
+    private createLogEntry;
+    /**
+     * Add a log entry to the internal log array.
+     * @param entry - Log entry to add
+     */
+    private addLogEntry;
+}

package/dist/plugin/Logger.js

@@ -0,0 +1,256 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import html2canvas from 'html2canvas';
+/**
+ * Singleton Logger class for Rimori client plugins.
+ * Handles all logging levels, production filtering, and log transmission to Rimori.
+ * Overrides console methods globally for seamless integration.
+ */
+export class Logger {
+    constructor(rimori, isProduction) {
+        this.logs = [];
+        this.logIdCounter = 0;
+        this.mousePosition = null;
+        this.isProduction = this.validateIsProduction(isProduction);
+        // Store original console methods
+        this.originalConsole = {
+            log: console.log,
+            info: console.info,
+            warn: console.warn,
+            error: console.error,
+            debug: console.debug
+        };
+        // Override console methods globally
+        this.overrideConsoleMethods();
+        // Track mouse position
+        this.trackMousePosition();
+        // Expose logs to global scope for DevTools access
+        this.exposeToDevTools();
+        // Set up navigation clearing
+        this.setupNavigationClearing();
+        rimori.event.respond('logging.requestPluginLogs', () => __awaiter(this, void 0, void 0, function* () {
+            this.addLogEntry(yield this.createLogEntry('info', 'Screenshot capture', undefined, true));
+            const logs = {
+                logs: this.logs,
+                pluginId: rimori.plugin.pluginId,
+                timestamp: new Date().toISOString()
+            };
+            this.logs = [];
+            this.logIdCounter = 0;
+            return logs;
+        }));
+    }
+    /**
+     * Initialize the Logger singleton and override console methods globally.
+     * @param rimori - Rimori client instance
+     * @param isProduction - Whether the environment is production
+     * @returns Logger instance
+     */
+    static getInstance(rimori, isProduction) {
+        if (!Logger.instance) {
+            Logger.instance = new Logger(rimori, isProduction);
+        }
+        return Logger.instance;
+    }
+    validateIsProduction(isProduction) {
+        if (isProduction !== undefined) {
+            return isProduction;
+        }
+        if (typeof window !== 'undefined' && window.location.href) {
+            return !window.location.href.includes('localhost');
+        }
+        return true;
+    }
+    /**
+     * Expose log access to global scope for DevTools console access.
+     */
+    exposeToDevTools() {
+        if (typeof window !== 'undefined') {
+            // Expose a global function to access logs from DevTools console
+            window.getRimoriLogs = () => this.logs;
+        }
+    }
+    /**
+     * Set up navigation event listeners to clear logs on page changes.
+     */
+    setupNavigationClearing() {
+        if (typeof window === 'undefined' || typeof history === 'undefined')
+            return;
+        // Clear logs on browser back/forward
+        window.addEventListener('popstate', () => this.logs = []);
+        // Override history methods to clear logs on programmatic navigation
+        const originalPushState = history.pushState;
+        const originalReplaceState = history.replaceState;
+        history.pushState = (...args) => {
+            originalPushState.apply(history, args);
+            this.logs = [];
+        };
+        history.replaceState = (...args) => {
+            originalReplaceState.apply(history, args);
+            this.logs = [];
+        };
+        // Listen for URL changes (works with React Router and other SPAs)
+        let currentUrl = window.location.href;
+        const checkUrlChange = () => {
+            if (window.location.href !== currentUrl) {
+                currentUrl = window.location.href;
+                this.logs = [];
+            }
+        };
+        // Check for URL changes periodically
+        setInterval(checkUrlChange, 100);
+        // Also listen for hash changes (for hash-based routing)
+        window.addEventListener('hashchange', () => this.logs = []);
+    }
+    /**
+     * Override console methods globally to capture all console calls.
+     */
+    overrideConsoleMethods() {
+        // Override console.log
+        console.log = (...args) => {
+            this.originalConsole.log(...args);
+            this.handleConsoleCall('info', args);
+        };
+        // Override console.info
+        console.info = (...args) => {
+            this.originalConsole.info(...args);
+            this.handleConsoleCall('info', args);
+        };
+        // Override console.warn
+        console.warn = (...args) => {
+            this.originalConsole.warn(...args);
+            this.handleConsoleCall('warn', args);
+        };
+        // Override console.error
+        console.error = (...args) => {
+            this.originalConsole.error(...args);
+            this.handleConsoleCall('error', args);
+        };
+        // Override console.debug
+        console.debug = (...args) => {
+            this.originalConsole.debug(...args);
+            this.handleConsoleCall('debug', args);
+        };
+    }
+    /**
+     * Track mouse position for screenshot context.
+     */
+    trackMousePosition() {
+        if (typeof window !== 'undefined') {
+            const updateMousePosition = (event) => {
+                this.mousePosition = {
+                    x: event.clientX,
+                    y: event.clientY,
+                    timestamp: new Date().toISOString()
+                };
+            };
+            window.addEventListener('mousemove', updateMousePosition);
+            window.addEventListener('click', updateMousePosition);
+        }
+    }
+    /**
+     * Handle console method calls and create log entries.
+     * @param level - Log level
+     * @param args - Console arguments
+     */
+    handleConsoleCall(level, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Skip if this is a production log that shouldn't be stored
+            if (this.isProduction && (level === 'debug' || level === 'info')) {
+                return;
+            }
+            // Convert console arguments to message and data
+            const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
+            const data = args.length > 1 ? args.slice(1) : undefined;
+            const entry = yield this.createLogEntry(level, message, data);
+            this.addLogEntry(entry);
+        });
+    }
+    /**
+     * Get browser and system information for debugging.
+     * @returns Object with browser and system information
+     */
+    getBrowserInfo() {
+        return {
+            userAgent: navigator.userAgent,
+            language: navigator.language,
+            cookieEnabled: navigator.cookieEnabled,
+            onLine: navigator.onLine,
+            screenResolution: `${screen.width}x${screen.height}`,
+            windowSize: `${window.innerWidth}x${window.innerHeight}`,
+            timestamp: new Date().toISOString()
+        };
+    }
+    /**
+     * Capture a screenshot of the current page.
+     * @returns Promise resolving to base64 screenshot or null if failed
+     */
+    captureScreenshot() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+                const canvas = yield html2canvas(document.body);
+                const screenshot = canvas.toDataURL('image/png');
+                // this.originalConsole.log("screenshot captured", screenshot)
+                return screenshot;
+            }
+            return null;
+        });
+    }
+    /**
+     * Create a log entry with context information.
+     * @param level - Log level
+     * @param message - Log message
+     * @param data - Additional data
+     * @returns Log entry
+     */
+    createLogEntry(level, message, data, forceScreenshot) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = {};
+            // Add URL if available
+            if (typeof window === 'undefined' || typeof document === 'undefined') {
+                return {
+                    id: `log_${++this.logIdCounter}_${Date.now()}`,
+                    timestamp: new Date().toISOString(),
+                    level,
+                    message,
+                    data,
+                };
+            }
+            context.url = window.location.href;
+            // Add browser info (this method now handles worker context internally)
+            context.browserInfo = this.getBrowserInfo();
+            context.userAgent = context.browserInfo.userAgent;
+            // Add screenshot and mouse position if level is error or warn
+            if (level === 'error' || level === 'warn' || forceScreenshot) {
+                context.screenshot = (yield this.captureScreenshot()) || undefined;
+                context.mousePosition = this.mousePosition || undefined;
+            }
+            return {
+                id: `log_${++this.logIdCounter}_${Date.now()}`,
+                timestamp: new Date().toISOString(),
+                level,
+                message,
+                data,
+                context: context
+            };
+        });
+    }
+    /**
+     * Add a log entry to the internal log array.
+     * @param entry - Log entry to add
+     */
+    addLogEntry(entry) {
+        this.logs.push(entry);
+        // Maintain log size limit (1000 entries)
+        if (this.logs.length > 1000) {
+            this.logs = this.logs.slice(-1000);
+        }
+    }
+}

package/dist/plugin/LoggerExample.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Example of how to integrate the Logger into a plugin's main entry point.
+ * This shows the complete setup process.
+ */
+export declare function initializePluginWithLogger(): Promise<void>;
+export declare function exampleComponentUsage(): {
+    handleUserAction: () => void;
+    handleApiError: (error: Error) => void;
+    handleDeprecatedFeature: () => void;
+};
+export declare function exampleLogManagement(): {
+    sendLogsToRimori: () => Promise<void>;
+    getLogStatistics: () => any;
+    exportLogsForDebugging: () => void;
+    clearOldLogs: () => void;
+};

package/dist/plugin/LoggerExample.js

@@ -0,0 +1,140 @@
+/**
+ * Example of how to integrate the Logger into a plugin's main entry point.
+ * This shows the complete setup process.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Logger } from './Logger';
+// Example plugin initialization with Logger integration
+export function initializePluginWithLogger() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // 1. Initialize the Logger singleton (call this as early as possible)
+        const logger = Logger.getInstance(process.env.NODE_ENV === 'production');
+        console.log('Logger initialized, console methods are now overridden globally');
+        try {
+            // 2. Initialize your plugin's core functionality
+            console.info('Starting plugin initialization...');
+            // 3. Get the Rimori client (this would be your actual client initialization)
+            const rimoriClient = yield getRimoriClient(); // Your actual client setup
+            // 4. Set the Rimori client in the Logger
+            logger.setRimoriClient(rimoriClient);
+            console.info('Plugin initialized successfully', {
+                version: '1.0.0',
+                environment: process.env.NODE_ENV,
+                timestamp: new Date().toISOString()
+            });
+            // 5. Set up periodic log transmission (optional)
+            setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                yield logger.sendRecentLogs(10); // Send last 10 logs every 5 minutes
+            }), 5 * 60 * 1000);
+            // 6. Set up error boundary for unhandled errors
+            window.addEventListener('error', (event) => {
+                console.error('Unhandled error caught by Logger', {
+                    message: event.message,
+                    filename: event.filename,
+                    lineno: event.lineno,
+                    colno: event.colno
+                });
+            });
+            window.addEventListener('unhandledrejection', (event) => {
+                console.error('Unhandled promise rejection caught by Logger', {
+                    reason: event.reason
+                });
+            });
+        }
+        catch (error) {
+            // This console.error will be automatically captured with screenshot + mouse position
+            console.error('Failed to initialize plugin', {
+                error: error.message,
+                stack: error.stack
+            });
+            // Send error logs immediately
+            yield logger.sendLogsByLevel('error');
+        }
+    });
+}
+// Example of how to use console methods in your components
+export function exampleComponentUsage() {
+    const handleUserAction = () => {
+        // These console calls are automatically captured by the Logger
+        console.log('User performed action', {
+            action: 'button_click',
+            timestamp: Date.now(),
+            userId: 'user123'
+        });
+    };
+    const handleApiError = (error) => {
+        // This console.error will include screenshot + mouse position
+        console.error('API request failed', {
+            endpoint: '/api/users',
+            error: error.message,
+            statusCode: 500
+        });
+    };
+    const handleDeprecatedFeature = () => {
+        // This console.warn will include screenshot + mouse position
+        console.warn('Deprecated feature used', {
+            feature: 'old-api-endpoint',
+            suggestedAlternative: 'new-api-endpoint'
+        });
+    };
+    return {
+        handleUserAction,
+        handleApiError,
+        handleDeprecatedFeature
+    };
+}
+// Example of log management utilities
+export function exampleLogManagement() {
+    const logger = Logger.getInstance(process.env.NODE_ENV === 'production');
+    const sendLogsToRimori = () => __awaiter(this, void 0, void 0, function* () {
+        yield logger.sendAllLogs();
+        console.log('All logs sent to Rimori');
+    });
+    const getLogStatistics = () => {
+        const stats = logger.getStats();
+        console.log('Log statistics:', stats);
+        return stats;
+    };
+    const exportLogsForDebugging = () => {
+        const exportedLogs = logger.exportLogs();
+        const blob = new Blob([exportedLogs], { type: 'application/json' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = `rimori-logs-${new Date().toISOString()}.json`;
+        a.click();
+        URL.revokeObjectURL(url);
+    };
+    const clearOldLogs = () => {
+        logger.clearLogs();
+        console.log('All logs cleared');
+    };
+    return {
+        sendLogsToRimori,
+        getLogStatistics,
+        exportLogsForDebugging,
+        clearOldLogs
+    };
+}
+// Mock function for demonstration
+function getRimoriClient() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // This would be your actual Rimori client initialization
+        return {
+            plugin: { pluginId: 'example-plugin' },
+            event: {
+                emit: (topic, data) => __awaiter(this, void 0, void 0, function* () {
+                    console.log('Sending to Rimori:', topic, data);
+                })
+            }
+        };
+    });
+}

package/dist/plugin/PluginController.d.ts

@@ -1,21 +1,46 @@
 import { SupabaseClient } from '@supabase/supabase-js';
+import { UserInfo } from '../core/controller/SettingsController';
+import { ActivePlugin, Plugin } from '../fromRimori/PluginTypes';
 import { RimoriClient } from "./RimoriClient";
+export interface RimoriInfo {
+    url: string;
+    key: string;
+    backendUrl: string;
+    token: string;
+    expiration: Date;
+    tablePrefix: string;
+    pluginId: string;
+    installedPlugins: Plugin[];
+    profile: UserInfo;
+    mainPanelPlugin?: ActivePlugin;
+    sidePanelPlugin?: ActivePlugin;
+}
 export declare class PluginController {
     private static client;
     private static instance;
-    private communicationSecret;
+    private port;
+    private queryParams;
     private supabase;
-    private supabaseInfo;
+    private rimoriInfo;
     private pluginId;
+    private isMessageChannelReady;
+    private pendingRequests;
     private constructor();
+    private initMessageChannel;
+    private sendHello;
     static getInstance(pluginId: string, standalone?: boolean): Promise<RimoriClient>;
-    private getSecret;
+    getQueryParam(key: string): string | null;
     getClient(): Promise<{
         supabase: SupabaseClient;
-        tablePrefix: string;
-        pluginId: string;
+        info: RimoriInfo;
     }>;
     getToken(): Promise<string>;
+    /**
+     * Gets the Supabase URL.
+     * @returns The Supabase URL.
+     * @deprecated All endpoints should use the backend URL instead.
+     */
     getSupabaseUrl(): string;
+    getBackendUrl(): string;
     getGlobalEventTopic(preliminaryTopic: string): string;
 }