@rimori/client 1.2.0 → 1.3.1

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,6 +1,6 @@
 import { SupabaseClient } from '@supabase/supabase-js';
 import { UserInfo } from '../core/controller/SettingsController';
-import { Plugin } from '../fromRimori/PluginTypes';
+import { ActivePlugin, Plugin } from '../fromRimori/PluginTypes';
 import { RimoriClient } from "./RimoriClient";
 export interface RimoriInfo {
     url: string;
@@ -12,22 +12,34 @@ export interface RimoriInfo {
     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 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;
         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;

package/dist/plugin/PluginController.js

@@ -12,37 +12,102 @@ import { EventBus } from '../fromRimori/EventBus';
 import { RimoriClient } from "./RimoriClient";
 import { StandaloneClient } from './StandaloneClient';
 import { setTheme } from './ThemeSetter';
+import { Logger } from './Logger';
 export class PluginController {
     constructor(pluginId, standalone) {
-        this.communicationSecret = null;
+        this.port = null;
+        this.queryParams = {};
         this.supabase = null;
         this.rimoriInfo = null;
+        this.isMessageChannelReady = false;
+        this.pendingRequests = [];
         this.pluginId = pluginId;
         this.getClient = this.getClient.bind(this);
         if (typeof WorkerGlobalScope === 'undefined') {
-            setTheme();
+            // In standalone mode, use URL fallback. In iframe mode, theme will be set after MessageChannel init
+            if (standalone) {
+                setTheme();
+            }
         }
-        //no need to forward messages to parent in standalone mode
+        //no need to forward messages to parent in standalone mode or worker context
         if (standalone)
             return;
-        window.addEventListener("message", (event) => {
-            // console.log("client: message received", event);
-            const { topic, sender, data, eventId } = event.data.event;
-            // skip forwarding messages from own plugin
-            if (sender === pluginId)
-                return;
-            EventBus.emit(sender, topic, data, eventId);
-        });
-        const secret = this.getSecret();
-        EventBus.on("*", (event) => {
-            // skip messages which are not from the own plugin
-            if (event.sender !== this.pluginId)
-                return;
-            if (event.topic.startsWith("self."))
+        this.initMessageChannel(typeof WorkerGlobalScope !== 'undefined');
+    }
+    initMessageChannel(worker = false) {
+        const listener = (event) => {
+            console.log("[PluginController] window message", { origin: event.origin, data: event.data });
+            const { type, pluginId, queryParams, rimoriInfo } = event.data || {};
+            const [transferredPort] = event.ports || [];
+            if (type !== "rimori:init" || !transferredPort || pluginId !== this.pluginId) {
+                console.log("[PluginController] message ignored (not init or wrong plugin)", { type, pluginId, hasPort: !!transferredPort });
                 return;
-            // console.log("sending event to parent", event);
-            window.parent.postMessage({ event, secret }, "*");
-        });
+            }
+            this.queryParams = queryParams || {};
+            this.port = transferredPort;
+            // Initialize Supabase client immediately with provided info
+            if (rimoriInfo) {
+                this.rimoriInfo = rimoriInfo;
+                this.supabase = createClient(rimoriInfo.url, rimoriInfo.key, {
+                    accessToken: () => Promise.resolve(rimoriInfo.token)
+                });
+            }
+            // Handle messages from parent
+            this.port.onmessage = ({ data }) => {
+                const { event, type, eventId, response, error } = data || {};
+                // no idea why this is needed but it works for now
+                if (type === 'response' && eventId) {
+                    EventBus.emit(this.pluginId, response.topic, response.data, eventId);
+                }
+                else if (type === 'error' && eventId) {
+                    EventBus.emit(this.pluginId, 'error', { error }, eventId);
+                }
+                else if (event) {
+                    const { topic, sender, data: eventData, eventId } = event;
+                    if (sender !== this.pluginId) {
+                        EventBus.emit(sender, topic, eventData, eventId);
+                    }
+                }
+            };
+            // Set theme from MessageChannel query params
+            if (!worker) {
+                const theme = this.queryParams['rm_theme'];
+                setTheme(theme);
+            }
+            // Forward plugin events to parent (only after MessageChannel is ready)
+            EventBus.on("*", (ev) => {
+                var _a;
+                if (ev.sender === this.pluginId && !ev.topic.startsWith("self.")) {
+                    (_a = this.port) === null || _a === void 0 ? void 0 : _a.postMessage({ event: ev });
+                }
+            });
+            // Mark MessageChannel as ready and process pending requests
+            this.isMessageChannelReady = true;
+            // Process any pending requests
+            this.pendingRequests.forEach(request => request());
+            this.pendingRequests = [];
+        };
+        if (worker) {
+            self.onmessage = listener;
+        }
+        else {
+            window.addEventListener("message", listener);
+        }
+        this.sendHello(worker);
+    }
+    sendHello(isWorker = false) {
+        try {
+            const payload = { type: "rimori:hello", pluginId: this.pluginId };
+            if (isWorker) {
+                self.postMessage(payload);
+            }
+            else {
+                window.parent.postMessage(payload, "*");
+            }
+        }
+        catch (e) {
+            console.error("[PluginController] Error sending hello:", e);
+        }
     }
     static getInstance(pluginId_1) {
         return __awaiter(this, arguments, void 0, function* (pluginId, standalone = false) {
@@ -52,32 +117,81 @@ export class PluginController {
                 }
                 PluginController.instance = new PluginController(pluginId, standalone);
                 PluginController.client = yield RimoriClient.getInstance(PluginController.instance);
+                //only init logger in workers and on main plugin pages
+                if (PluginController.instance.getQueryParam("applicationMode") !== "sidebar") {
+                    Logger.getInstance(PluginController.client);
+                }
             }
             return PluginController.client;
         });
     }
-    getSecret() {
-        if (!this.communicationSecret) {
-            const secret = new URLSearchParams(window.location.search).get("secret");
-            if (!secret) {
-                console.info("Communication secret not found in URL as query parameter");
-            }
-            this.communicationSecret = secret;
-        }
-        return this.communicationSecret;
+    getQueryParam(key) {
+        return this.queryParams[key] || null;
     }
     getClient() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.supabase &&
-                this.rimoriInfo &&
-                this.rimoriInfo.expiration > new Date()) {
+            // Return cached client if valid
+            if (this.supabase && this.rimoriInfo && this.rimoriInfo.expiration > new Date()) {
                 return { supabase: this.supabase, info: this.rimoriInfo };
             }
-            const { data } = yield EventBus.request(this.pluginId, "global.supabase.requestAccess");
-            this.rimoriInfo = data;
-            this.supabase = createClient(this.rimoriInfo.url, this.rimoriInfo.key, {
-                accessToken: () => Promise.resolve(this.getToken())
-            });
+            // If MessageChannel is not ready yet, queue the request
+            if (!this.isMessageChannelReady) {
+                return new Promise((resolve) => {
+                    this.pendingRequests.push(() => __awaiter(this, void 0, void 0, function* () {
+                        const result = yield this.getClient();
+                        resolve(result);
+                    }));
+                });
+            }
+            // If we have rimoriInfo from MessageChannel init, use it directly
+            if (this.rimoriInfo && this.supabase) {
+                return { supabase: this.supabase, info: this.rimoriInfo };
+            }
+            // Fallback: request from parent
+            if (!this.rimoriInfo) {
+                if (typeof WorkerGlobalScope !== 'undefined') {
+                    // In worker context, send request via self.postMessage to WorkerHandler
+                    const eventId = Math.floor(Math.random() * 1000000000);
+                    const requestEvent = {
+                        event: {
+                            timestamp: new Date().toISOString(),
+                            eventId,
+                            sender: this.pluginId,
+                            topic: 'global.supabase.requestAccess',
+                            data: {},
+                            debug: false
+                        }
+                    };
+                    return new Promise((resolve) => {
+                        // Listen for the response
+                        const originalOnMessage = self.onmessage;
+                        self.onmessage = (event) => {
+                            var _a, _b;
+                            if (((_a = event.data) === null || _a === void 0 ? void 0 : _a.topic) === 'global.supabase.requestAccess' && ((_b = event.data) === null || _b === void 0 ? void 0 : _b.eventId) === eventId) {
+                                this.rimoriInfo = event.data.data;
+                                this.supabase = createClient(this.rimoriInfo.url, this.rimoriInfo.key, {
+                                    accessToken: () => Promise.resolve(this.getToken())
+                                });
+                                self.onmessage = originalOnMessage; // Restore original handler
+                                resolve({ supabase: this.supabase, info: this.rimoriInfo });
+                            }
+                            else if (originalOnMessage) {
+                                originalOnMessage.call(self, event);
+                            }
+                        };
+                        // Send the request
+                        self.postMessage(requestEvent);
+                    });
+                }
+                else {
+                    // In main thread context, use EventBus
+                    const { data } = yield EventBus.request(this.pluginId, "global.supabase.requestAccess");
+                    this.rimoriInfo = data;
+                    this.supabase = createClient(this.rimoriInfo.url, this.rimoriInfo.key, {
+                        accessToken: () => Promise.resolve(this.getToken())
+                    });
+                }
+            }
             return { supabase: this.supabase, info: this.rimoriInfo };
         });
     }
@@ -86,15 +200,24 @@ export class PluginController {
             if (this.rimoriInfo && this.rimoriInfo.expiration && this.rimoriInfo.expiration > new Date()) {
                 return this.rimoriInfo.token;
             }
-            const { data } = yield EventBus.request(this.pluginId, "global.supabase.requestAccess");
+            // If we don't have rimoriInfo, request it
             if (!this.rimoriInfo) {
-                throw new Error("Supabase info not found");
+                const { data } = yield EventBus.request(this.pluginId, "global.supabase.requestAccess");
+                this.rimoriInfo = data;
+                return this.rimoriInfo.token;
             }
+            // If token is expired, request fresh access
+            const { data } = yield EventBus.request(this.pluginId, "global.supabase.requestAccess");
             this.rimoriInfo.token = data.token;
             this.rimoriInfo.expiration = data.expiration;
             return this.rimoriInfo.token;
         });
     }
+    /**
+     * Gets the Supabase URL.
+     * @returns The Supabase URL.
+     * @deprecated All endpoints should use the backend URL instead.
+     */
     getSupabaseUrl() {
         if (!this.rimoriInfo) {
             throw new Error("Supabase info not found");

package/dist/plugin/RimoriClient.d.ts

@@ -1,12 +1,11 @@
 import { PostgrestQueryBuilder } from "@supabase/postgrest-js";
-import { SupabaseClient } from "@supabase/supabase-js";
 import { GenericSchema } from "@supabase/supabase-js/dist/module/lib/types";
 import { Message, OnLLMResponse } from "../core/controller/AIController";
 import { ObjectRequest } from "../core/controller/ObjectController";
 import { UserInfo } from "../core/controller/SettingsController";
 import { SharedContent, SharedContentFilter, SharedContentObjectRequest } from "../core/controller/SharedContentController";
 import { EventBusMessage, EventHandler, EventPayload } from "../fromRimori/EventBus";
-import { Plugin, Tool } from "../fromRimori/PluginTypes";
+import { ActivePlugin, MainPanelAction, Plugin, Tool } from "../fromRimori/PluginTypes";
 import { AccomplishmentPayload } from "./AccomplishmentHandler";
 import { PluginController } from "./PluginController";
 interface Db {
@@ -14,7 +13,6 @@ interface Db {
         <TableName extends string & keyof GenericSchema['Tables'], Table extends GenericSchema['Tables'][TableName]>(relation: TableName): PostgrestQueryBuilder<GenericSchema, Table, TableName>;
         <ViewName extends string & keyof GenericSchema['Views'], View extends GenericSchema['Views'][ViewName]>(relation: ViewName): PostgrestQueryBuilder<GenericSchema, View, ViewName>;
     };
-    storage: SupabaseClient["storage"];
     /**
      * The table prefix for of database tables of the plugin.
      */
@@ -38,11 +36,26 @@ interface PluginInterface {
      */
     getSettings: <T extends object>(defaultSettings: T) => Promise<T>;
     /**
-    * Fetches all installed plugins.
-    * @returns A promise that resolves to an array of plugins
-    */
-    getInstalled: () => Promise<Plugin[]>;
-    getUserInfo: () => Promise<UserInfo>;
+     * Retrieves information about plugins, including:
+     * - All installed plugins
+     * - The currently active plugin in the main panel
+     * - The currently active plugin in the side panel
+     */
+    getPluginInfo: () => {
+        /**
+         * All installed plugins.
+         */
+        installedPlugins: Plugin[];
+        /**
+         * The plugin that is loaded in the main panel.
+         */
+        mainPanelPlugin?: ActivePlugin;
+        /**
+         * The plugin that is loaded in the side panel.
+         */
+        sidePanelPlugin?: ActivePlugin;
+    };
+    getUserInfo: () => UserInfo;
 }
 export declare class RimoriClient {
     private static instance;
@@ -51,9 +64,7 @@ export declare class RimoriClient {
     private settingsController;
     private sharedContentController;
     private accomplishmentHandler;
-    private supabaseUrl;
-    private installedPlugins;
-    private profile;
+    private rimoriInfo;
     plugin: PluginInterface;
     db: Db;
     private constructor();
@@ -113,10 +124,17 @@ export declare class RimoriClient {
          * @param text Optional text to be used for the action like for example text that the translator would look up.
          */
         emitSidebarAction: (pluginId: string, actionKey: string, text?: string) => void;
+        onMainPanelAction: (callback: (data: MainPanelAction) => void) => void;
     };
     navigation: {
         toDashboard: () => void;
     };
+    /**
+     * Get a query parameter value that was passed via MessageChannel
+     * @param key The query parameter key
+     * @returns The query parameter value or null if not found
+     */
+    getQueryParam(key: string): string | null;
     static getInstance(pluginController: PluginController): Promise<RimoriClient>;
     private from;
     private getTableName;
@@ -127,6 +145,9 @@ export declare class RimoriClient {
         getTextFromVoice: (file: Blob) => Promise<string>;
         getObject: (request: ObjectRequest) => Promise<any>;
     };
+    runtime: {
+        fetchBackend: (url: string, options: RequestInit) => Promise<Response>;
+    };
     community: {
         /**
          * Shared content is a way to share completable content with other users using this plugin.
@@ -154,10 +175,19 @@ export declare class RimoriClient {
              * @param contentType The type of shared content to fetch. E.g. assignments, exercises, etc.
              * @param generatorInstructions The instructions for the creation of new shared content. The object will automatically be extended with a tool property with a topic and keywords property to let a new unique topic be generated.
              * @param filter The optional additional filter for checking new shared content based on a column and value. This is useful if the aditional information stored on the shared content is used to further narrow down the kind of shared content wanted to be received. E.g. only adjective grammar exercises.
-             * @param privateTopic An optional flag to indicate if the topic should be private and only be visible to the user. This is useful if the topic is not meant to be shared with other users. Like for personal topics or if the content is based on the personal study goal.
+             * @param options An optional object with options for the new shared content.
+             * @param options.privateTopic An optional flag to indicate if the topic should be private and only be visible to the user. This is useful if the topic is not meant to be shared with other users. Like for personal topics or if the content is based on the personal study goal.
+             * @param options.skipDbSave An optional flag to indicate if the new shared content should not be saved to the database. This is useful if the new shared content is not meant to be saved to the database.
+             * @param options.alwaysGenerateNew An optional flag to indicate if the new shared content should always be generated even if there is already a content with the same filter. This is useful if the new shared content is not meant to be saved to the database.
+             * @param options.excludeIds An optional list of ids to exclude from the selection. This is useful if the new shared content is not meant to be saved to the database.
              * @returns The new shared content.
              */
-            getNew: <T = any>(contentType: string, generatorInstructions: SharedContentObjectRequest, filter?: SharedContentFilter, privateTopic?: boolean) => Promise<SharedContent<T>>;
+            getNew: <T = any>(contentType: string, generatorInstructions: SharedContentObjectRequest, filter?: SharedContentFilter, options?: {
+                privateTopic?: boolean;
+                skipDbSave?: boolean;
+                alwaysGenerateNew?: boolean;
+                excludeIds?: string[];
+            }) => Promise<SharedContent<T>>;
             /**
              * Create a new shared content item.
              * @param content The content to create.
@@ -177,6 +207,18 @@ export declare class RimoriClient {
               * @param assignmentId The id of the shared content item to complete.
               */
             complete: (contentType: string, assignmentId: string) => Promise<void>;
+            /**
+             /**
+              * Update the state of a shared content item for a specific user.
+              * Useful for marking content as completed, ongoing, hidden, liked, disliked, or bookmarked.
+              */
+            updateState: (params: {
+                contentType: string;
+                id: string;
+                state?: "completed" | "ongoing" | "hidden";
+                reaction?: "liked" | "disliked" | null;
+                bookmarked?: boolean;
+            }) => Promise<void>;
             /**
              * Remove a shared content item.
              * @param id The id of the shared content item to remove.