@rimori/client 1.1.10 → 1.3.0

package/dist/plugin/PluginController.js

@@ -8,41 +8,106 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { createClient } from '@supabase/supabase-js';
-import { EventBus } from './fromRimori/EventBus';
+import { EventBus } from '../fromRimori/EventBus';
 import { RimoriClient } from "./RimoriClient";
-import { setTheme } from './ThemeSetter';
 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.supabaseInfo = 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,54 +117,118 @@ 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.supabaseInfo &&
-                this.supabaseInfo.expiration > new Date()) {
-                return { supabase: this.supabase, tablePrefix: this.supabaseInfo.tablePrefix, pluginId: this.supabaseInfo.pluginId };
+            // 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.supabaseInfo = data;
-            this.supabase = createClient(this.supabaseInfo.url, this.supabaseInfo.key, {
-                accessToken: () => Promise.resolve(this.getToken())
-            });
-            return { supabase: this.supabase, tablePrefix: this.supabaseInfo.tablePrefix, pluginId: this.supabaseInfo.pluginId };
+            // 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 };
         });
     }
     getToken() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.supabaseInfo && this.supabaseInfo.expiration && this.supabaseInfo.expiration > new Date()) {
-                return this.supabaseInfo.token;
+            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 (!this.supabaseInfo) {
-                throw new Error("Supabase info not found");
+            // If we don't have rimoriInfo, request it
+            if (!this.rimoriInfo) {
+                const { data } = yield EventBus.request(this.pluginId, "global.supabase.requestAccess");
+                this.rimoriInfo = data;
+                return this.rimoriInfo.token;
             }
-            this.supabaseInfo.token = data.token;
-            this.supabaseInfo.expiration = data.expiration;
-            return this.supabaseInfo.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.supabaseInfo) {
+        if (!this.rimoriInfo) {
             throw new Error("Supabase info not found");
         }
-        return this.supabaseInfo.url;
+        return this.rimoriInfo.url;
+    }
+    getBackendUrl() {
+        if (!this.rimoriInfo) {
+            throw new Error("Rimori info not found");
+        }
+        return this.rimoriInfo.backendUrl;
     }
     getGlobalEventTopic(preliminaryTopic) {
         var _a, _b;
@@ -119,7 +248,7 @@ export class PluginController {
         else if (topicParts.length > 3) {
             throw new Error(`The event topic must consist of 3 parts. <pluginId>.<topic area>.<action>. Received: ${preliminaryTopic}`);
         }
-        const topicRoot = (_b = (_a = this.supabaseInfo) === null || _a === void 0 ? void 0 : _a.pluginId) !== null && _b !== void 0 ? _b : "global";
+        const topicRoot = (_b = (_a = this.rimoriInfo) === null || _a === void 0 ? void 0 : _a.pluginId) !== null && _b !== void 0 ? _b : "global";
         return `${topicRoot}.${preliminaryTopic}`;
     }
 }

package/dist/plugin/RimoriClient.d.ts

@@ -1,20 +1,18 @@
 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, Tool } from "../controller/AIController";
-import { ObjectRequest } from "../controller/ObjectController";
-import { UserInfo } from "../controller/SettingsController";
-import { SharedContent, SharedContentFilter, SharedContentObjectRequest } from "../controller/SharedContentController";
+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 { ActivePlugin, MainPanelAction, Plugin, Tool } from "../fromRimori/PluginTypes";
 import { AccomplishmentPayload } from "./AccomplishmentHandler";
-import { EventBusMessage, EventHandler, EventPayload } from "./fromRimori/EventBus";
-import { Plugin } from "./fromRimori/PluginTypes";
 import { PluginController } from "./PluginController";
 interface Db {
     from: {
         <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,9 @@ export declare class RimoriClient {
     private settingsController;
     private sharedContentController;
     private accomplishmentHandler;
-    private supabaseUrl;
-    db: Db;
+    private rimoriInfo;
     plugin: PluginInterface;
+    db: Db;
     private constructor();
     event: {
         /**
@@ -78,9 +91,9 @@ export declare class RimoriClient {
          * Subscribe to an event.
          * @param topic The topic to subscribe to.
          * @param callback The callback to call when the event is emitted.
-         * @returns The unsubscribe ids.
+         * @returns An EventListener object containing an off() method to unsubscribe the listeners.
          */
-        on: <T = EventPayload>(topic: string | string[], callback: EventHandler<T>) => import("./fromRimori/EventBus").EventListener[];
+        on: <T = EventPayload>(topic: string | string[], callback: EventHandler<T>) => import("../fromRimori/EventBus").EventListener;
         /**
          * Subscribe to an event once.
          * @param topic The topic to subscribe to.
@@ -92,7 +105,7 @@ export declare class RimoriClient {
          * @param topic The topic to respond to.
          * @param data The data to respond with.
          */
-        respond: <T = EventPayload>(topic: string, data: EventPayload | ((data: EventBusMessage<T>) => EventPayload | Promise<EventPayload>)) => void;
+        respond: <T = EventPayload>(topic: string | string[], data: EventPayload | ((data: EventBusMessage<T>) => EventPayload | Promise<EventPayload>)) => void;
         /**
          * Emit an accomplishment.
          * @param payload The payload to emit.
@@ -111,17 +124,30 @@ 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;
-    llm: {
+    ai: {
         getText: (messages: Message[], tools?: Tool[]) => Promise<string>;
         getSteamedText: (messages: Message[], onMessage: OnLLMResponse, tools?: Tool[]) => Promise<void>;
         getVoice: (text: string, voice?: string, speed?: number, language?: string) => Promise<Blob>;
         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.
@@ -149,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.
@@ -172,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.