@rimori/client 2.2.0 → 2.3.0-next.1

package/.github/workflows/pre-release.yml

@@ -0,0 +1,126 @@
+name: Pre-Release Rimori Client
+
+on:
+  push:
+    branches: [dev]
+    paths:
+      - '**'
+      - '!.github/workflows/**'
+
+jobs:
+  pre-release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+          cache: 'yarn'
+          cache-dependency-path: yarn.lock
+
+      - name: Update npm
+        run: npm install -g npm@latest
+
+      - name: Install dependencies
+        run: yarn install --frozen-lockfile
+
+      - name: Build rimori-client (TypeScript verification)
+        run: yarn build
+
+      - name: Calculate next pre-release version
+        id: version
+        run: |
+          # Read current version from package.json (may be base or pre-release)
+          CURRENT_VERSION=$(node -p "require('./package.json').version")
+
+          # Extract base version (strip any pre-release suffix)
+          # Examples: "2.2.0" -> "2.2.0", "2.2.0-next.5" -> "2.2.0"
+          if [[ "$CURRENT_VERSION" =~ ^([0-9]+\.[0-9]+\.[0-9]+) ]]; then
+            BASE_VERSION="${BASH_REMATCH[1]}"
+          else
+            BASE_VERSION="$CURRENT_VERSION"
+          fi
+
+          # Try to get latest next version from npm
+          LATEST_NEXT=$(npm view @rimori/client@next version 2>/dev/null || echo "none")
+
+          if [ "$LATEST_NEXT" != "none" ]; then
+            # Extract base version and pre-release number from latest next version
+            # Example: "2.2.0-next.5" -> extract "2.2.0" and "5"
+            if [[ "$LATEST_NEXT" =~ ^([0-9]+\.[0-9]+\.[0-9]+)-next\.([0-9]+)$ ]]; then
+              LATEST_BASE="${BASH_REMATCH[1]}"
+              PRERELEASE_NUM="${BASH_REMATCH[2]}"
+              
+              # If base version changed, reset to 1, otherwise increment
+              if [ "$LATEST_BASE" != "$BASE_VERSION" ]; then
+                NEW_NUM=1
+              else
+                NEW_NUM=$((PRERELEASE_NUM + 1))
+              fi
+            else
+              # Fallback: if format doesn't match, start at 1
+              NEW_NUM=1
+            fi
+          else
+            # First pre-release
+            NEW_NUM=1
+          fi
+
+          NEW_VERSION="${BASE_VERSION}-next.${NEW_NUM}"
+          echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
+          echo "Base version: $BASE_VERSION"
+          echo "Calculated next version: $NEW_VERSION"
+
+      - name: Update package.json version
+        run: |
+          # Use node to update version directly (yarn version creates git tags)
+          node -e "const fs = require('fs'); const pkg = JSON.parse(fs.readFileSync('package.json')); pkg.version = '${{ steps.version.outputs.new_version }}'; fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2) + '\n');"
+
+      - name: Publish to npm
+        run: npm publish --tag next --access public
+        # Uses OIDC token automatically (no NODE_AUTH_TOKEN needed)
+        # Requires npm 11.5.1+ and id-token: write permission (already set)
+
+      - name: Output published version
+        run: |
+          echo "✅ Published @rimori/client@${{ steps.version.outputs.new_version }} to npm with @next tag"
+
+      - name: Create git tag
+        run: |
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+          git tag "v${{ steps.version.outputs.new_version }}" -m "Pre-release v${{ steps.version.outputs.new_version }}"
+          git push origin "v${{ steps.version.outputs.new_version }}"
+          echo "🏷️ Created and pushed tag v${{ steps.version.outputs.new_version }}"
+
+      - name: Notify Slack
+        if: always()
+        uses: slackapi/slack-github-action@v1.24.0
+        with:
+          channel-id: ${{ secrets.SLACK_CHANNEL_ID }}
+          payload: |
+            {
+              "text": "Pre-Release Pipeline Status",
+              "blocks": [
+                {
+                  "type": "section",
+                  "text": {
+                    "type": "mrkdwn",
+                    "text": "📦 *@rimori/client Pre-Release*\n\n*Branch:* ${{ github.ref_name }}\n*Version:* ${{ steps.version.outputs.new_version }}\n*Author:* ${{ github.actor }}\n*Pipeline:* <${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}|View Run>\n\n${{ job.status == 'success' && '✅ Successfully published to npm with @next tag!' || '❌ Pipeline failed. Check the logs for details.' }}"
+                  }
+                }
+              ]
+            }
+        env:
+          SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}

package/README.md

@@ -3,6 +3,7 @@
 The `@rimori/client` package is the framework-agnostic runtime and CLI that powers Rimori plugins. Use it inside plugin iframes, workers, and build scripts to access Rimori platform features such as database access, AI, shared content, and the event bus. All React-specific helpers and UI components are now published separately in `@rimori/react-client`.
 
 ## Table of Contents
+
 - [Overview](#overview)
 - [Installation](#installation)
 - [Relationship to @rimori/react-client](#relationship-to-rimori-react-client)
@@ -24,6 +25,7 @@ The `@rimori/client` package is the framework-agnostic runtime and CLI that powe
 ## Overview
 
 `@rimori/client` gives you direct, typed access to the Rimori platform:
+
 - Bootstrap authenticated plugin sessions and fetch Rimori context.
 - Run Supabase queries against your plugin's dedicated schema.
 - Call AI services for text, structured data, or voice.
@@ -54,18 +56,15 @@ npm install @rimori/react-client
 Instantiate the client once in your application entry point and reuse it everywhere:
 
 ```ts
-import { RimoriClient } from "@rimori/client";
+import { RimoriClient } from '@rimori/client';
 
 async function bootstrap() {
-  const client = await RimoriClient.getInstance("your-plugin-id");
+  const client = await RimoriClient.getInstance('your-plugin-id');
 
   const user = client.plugin.getUserInfo();
-  const { data } = await client.db
-    .from("notes")
-    .select("*")
-    .eq("user_id", user.profile_id);
+  const { data } = await client.db.from('notes').select('*').eq('user_id', user.profile_id);
 
-  console.log("Loaded notes", data);
+  console.log('Loaded notes', data);
 }
 
 bootstrap().catch(console.error);
@@ -127,10 +126,7 @@ Access metadata and settings through `client.plugin`:
 `client.db` wraps the Supabase client that is scoped to your plugin tables:
 
 ```ts
-const { data, error } = await client.db
-  .from("study_sessions")
-  .select("*")
-  .order("completed_at", { ascending: false });
+const { data, error } = await client.db.from('study_sessions').select('*').order('completed_at', { ascending: false });
 ```
 
 Helpers:
@@ -196,7 +192,7 @@ Import additional helpers as needed:
 All exports are fully typed. You can import the type definitions directly:
 
 ```ts
-import type { Message, Tool, SharedContent, MacroAccomplishmentPayload } from "@rimori/client";
+import type { Message, Tool, SharedContent, MacroAccomplishmentPayload } from '@rimori/client';
 ```
 
 The generated declaration files cover every controller and helper to keep plugins strictly typed.
@@ -206,7 +202,7 @@ The generated declaration files cover every controller and helper to keep plugin
 React users should install `@rimori/react-client` and wrap their app:
 
 ```tsx
-import { PluginProvider, useRimori, useChat } from "@rimori/react-client";
+import { PluginProvider, useRimori, useChat } from '@rimori/react-client';
 
 function Dashboard() {
   const client = useRimori();

package/dist/controller/SettingsController.d.ts

@@ -16,6 +16,7 @@ export interface Language {
     capitalized: string;
     uppercase: string;
 }
+export type UserRole = 'user' | 'plugin_moderator' | 'lang_moderator' | 'admin';
 export interface UserInfo {
     skill_level_reading: LanguageLevel;
     skill_level_writing: LanguageLevel;
@@ -29,8 +30,7 @@ export interface UserInfo {
     story_genre: string;
     study_duration: number;
     /**
-     * The 2 letter language code of the language the user speaks natively.
-     * With the function getLanguageName, the language name can be retrieved.
+     * The language the user speaks natively.
      */
     mother_tongue: Language;
     /**
@@ -49,6 +49,10 @@ export interface UserInfo {
      * Optional: nearest big city (>100,000) near user's location
      */
     target_city?: string;
+    /**
+     * The user's role: 'user', 'plugin_moderator', 'lang_moderator', or 'admin'
+     */
+    user_role: UserRole;
 }
 export declare class SettingsController {
     private pluginId;

package/dist/controller/TranslationController.d.ts

@@ -4,9 +4,11 @@ import { ThirdPartyModule, TOptions } from 'i18next';
  */
 export declare class Translator {
     private currentLanguage;
-    private isInitialized;
+    private initializationState;
+    private initializationPromise;
     private i18n;
-    constructor(initialLanguage: string);
+    private translationUrl;
+    constructor(initialLanguage: string, translationUrl: string);
     /**
      * Initialize translator with user's language
      * @param userLanguage - Language code from user info

package/dist/controller/TranslationController.js

@@ -12,9 +12,11 @@ import { createInstance } from 'i18next';
  * Translator class for handling internationalization
  */
 export class Translator {
-    constructor(initialLanguage) {
-        this.isInitialized = false;
+    constructor(initialLanguage, translationUrl) {
         this.currentLanguage = initialLanguage;
+        this.initializationState = 'not-inited';
+        this.initializationPromise = null;
+        this.translationUrl = translationUrl;
     }
     /**
      * Initialize translator with user's language
@@ -22,21 +24,41 @@ export class Translator {
      */
     initialize() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.isInitialized)
+            // If already finished, return immediately
+            if (this.initializationState === 'finished') {
                 return;
-            const translations = yield this.fetchTranslations(this.currentLanguage);
-            const instance = createInstance({
-                lng: this.currentLanguage,
-                resources: {
-                    [this.currentLanguage]: {
-                        translation: translations,
-                    },
-                },
-                debug: window.location.hostname === 'localhost',
-            });
-            yield instance.init();
-            this.i18n = instance;
-            this.isInitialized = true;
+            }
+            // If currently initializing, wait for the existing initialization to complete
+            if (this.initializationState === 'initing' && this.initializationPromise) {
+                return this.initializationPromise;
+            }
+            // Start initialization
+            this.initializationState = 'initing';
+            // Create a promise that will be resolved when initialization completes
+            this.initializationPromise = (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const translations = yield this.fetchTranslations(this.currentLanguage);
+                    const instance = createInstance({
+                        lng: this.currentLanguage,
+                        resources: {
+                            [this.currentLanguage]: {
+                                translation: translations,
+                            },
+                        },
+                        debug: window.location.hostname === 'localhost',
+                    });
+                    yield instance.init();
+                    this.i18n = instance;
+                    this.initializationState = 'finished';
+                }
+                catch (error) {
+                    // Reset state on error so it can be retried
+                    this.initializationState = 'not-inited';
+                    this.initializationPromise = null;
+                    throw error;
+                }
+            }))();
+            return this.initializationPromise;
         });
     }
     getTranslationUrl(language) {
@@ -45,7 +67,7 @@ export class Translator {
             const filename = language !== 'en' ? `local-${language}` : language;
             return `${window.location.origin}/locales/${filename}.json`;
         }
-        return `./locales/${language}.json`;
+        return `${this.translationUrl}/locales/${language}.json`;
     }
     usePlugin(plugin) {
         if (!this.i18n) {
@@ -101,6 +123,6 @@ export class Translator {
      * Check if translator is initialized
      */
     isReady() {
-        return this.isInitialized;
+        return this.initializationState === 'finished';
     }
 }

package/dist/fromRimori/EventBus.js

@@ -12,18 +12,18 @@ export class EventBusHandler {
         this.listeners = new Map();
         this.responseResolvers = new Map();
         this.debugEnabled = false;
-        this.evName = "";
+        this.evName = '';
         //private constructor
     }
     static getInstance(name) {
         if (!EventBusHandler.instance) {
             EventBusHandler.instance = new EventBusHandler();
-            EventBusHandler.instance.on("global.system.requestDebug", () => {
+            EventBusHandler.instance.on('global.system.requestDebug', () => {
                 EventBusHandler.instance.debugEnabled = true;
                 console.log(`[${EventBusHandler.instance.evName}] Debug mode enabled. Make sure debugging messages are enabled in the browser console.`);
             });
         }
-        if (name && EventBusHandler.instance.evName === "") {
+        if (name && EventBusHandler.instance.evName === '') {
             EventBusHandler.instance.evName = name;
         }
         return EventBusHandler.instance;
@@ -67,7 +67,7 @@ export class EventBusHandler {
         }
         const event = this.createEvent(sender, topic, data, eventId);
         const handlers = this.getMatchingHandlers(event.topic);
-        handlers.forEach(handler => {
+        handlers.forEach((handler) => {
             if (handler.ignoreSender && handler.ignoreSender.includes(sender)) {
                 // console.log("ignore event as its in the ignoreSender list", { event, ignoreList: handler.ignoreSender });
                 return;
@@ -93,7 +93,7 @@ export class EventBusHandler {
      * @returns An EventListener object containing an off() method to unsubscribe the listeners.
      */
     on(topics, handler, ignoreSender = []) {
-        const ids = this.toArray(topics).map(topic => {
+        const ids = this.toArray(topics).map((topic) => {
             this.logIfDebug(`Subscribing to ` + topic, { ignoreSender });
             if (!this.validateTopic(topic)) {
                 this.logAndThrowError(true, `Invalid topic: ` + topic);
@@ -102,14 +102,31 @@ export class EventBusHandler {
                 this.listeners.set(topic, new Set());
             }
             const id = Math.floor(Math.random() * 10000000000);
-            // Type assertion to handle the generic type mismatch
-            const eventHandler = handler;
+            // To prevent infinite loops and processing the same eventId multiple times
+            const blackListedEventIds = [];
+            const eventHandler = (data) => {
+                if (blackListedEventIds.some((item) => item.eventId === data.eventId && item.sender === data.sender)) {
+                    console.log('BLACKLISTED EVENT ID', data.eventId, data);
+                    return;
+                }
+                blackListedEventIds.push({
+                    eventId: data.eventId,
+                    sender: data.sender,
+                });
+                if (blackListedEventIds.length > 100) {
+                    blackListedEventIds.shift();
+                }
+                return handler(data);
+            };
             this.listeners.get(topic).add({ id, handler: eventHandler, ignoreSender });
-            this.logIfDebug(`Subscribed to ` + topic, { listenerId: id, ignoreSender });
+            this.logIfDebug(`Subscribed to ` + topic, {
+                listenerId: id,
+                ignoreSender,
+            });
             return btoa(JSON.stringify({ topic, id }));
         });
         return {
-            off: () => this.off(ids)
+            off: () => this.off(ids),
         };
     }
     /**
@@ -121,29 +138,29 @@ export class EventBusHandler {
      */
     respond(sender, topic, handler) {
         const topics = Array.isArray(topic) ? topic : [topic];
-        const listeners = topics.map(topic => {
+        const listeners = topics.map((topic) => {
             const blackListedEventIds = [];
             //To allow event communication inside the same plugin the sender needs to be ignored but the events still need to be checked for the same event just reaching the subscriber to prevent infinite loops
-            const finalIgnoreSender = !topic.startsWith("self.") ? [sender] : [];
+            const finalIgnoreSender = !topic.startsWith('self.') ? [sender] : [];
             const listener = this.on(topic, (data) => __awaiter(this, void 0, void 0, function* () {
                 if (blackListedEventIds.includes(data.eventId)) {
                     // console.log("BLACKLISTED EVENT ID", data.eventId);
                     return;
                 }
                 blackListedEventIds.push(data.eventId);
-                if (blackListedEventIds.length > 20) {
+                if (blackListedEventIds.length > 100) {
                     blackListedEventIds.shift();
                 }
-                const response = typeof handler === "function" ? yield handler(data) : handler;
+                const response = typeof handler === 'function' ? yield handler(data) : handler;
                 this.emit(sender, topic, response, data.eventId);
             }), finalIgnoreSender);
-            this.logIfDebug(`Added respond listener ` + sender + " to topic " + topic, { listener, sender });
+            this.logIfDebug(`Added respond listener ` + sender + ' to topic ' + topic, { listener, sender });
             return {
-                off: () => listener.off()
+                off: () => listener.off(),
             };
         });
         return {
-            off: () => listeners.forEach(listener => listener.off())
+            off: () => listeners.forEach((listener) => listener.off()),
         };
     }
     /**
@@ -156,7 +173,7 @@ export class EventBusHandler {
             this.logAndThrowError(false, `Invalid topic: ` + topic);
             return;
         }
-        let listener;
+        let listener = undefined;
         const wrapper = (event) => {
             handler(event);
             listener === null || listener === void 0 ? void 0 : listener.off();
@@ -169,13 +186,16 @@ export class EventBusHandler {
      * @param listenerIds - The ids of the listeners to unsubscribe from.
      */
     off(listenerIds) {
-        this.toArray(listenerIds).forEach(fullId => {
+        this.toArray(listenerIds).forEach((fullId) => {
             const { topic, id } = JSON.parse(atob(fullId));
             const listeners = this.listeners.get(topic) || new Set();
-            listeners.forEach(listener => {
+            listeners.forEach((listener) => {
                 if (listener.id === Number(id)) {
                     listeners.delete(listener);
-                    this.logIfDebug(`Removed listener ` + fullId, { topic, listenerId: id });
+                    this.logIfDebug(`Removed listener ` + fullId, {
+                        topic,
+                        listenerId: id,
+                    });
                 }
             });
         });
@@ -197,7 +217,7 @@ export class EventBusHandler {
             }
             const event = this.createEvent(sender, topic, data || {});
             this.logIfDebug(`Requesting data from ` + topic, { event });
-            return new Promise(resolve => {
+            return new Promise((resolve) => {
                 this.responseResolvers.set(event.eventId, (value) => resolve(value));
                 this.emitInternal(sender, topic, data || {}, event.eventId, true);
             });
@@ -212,7 +232,7 @@ export class EventBusHandler {
         const exact = this.listeners.get(topic) || new Set();
         // Find wildcard matches
         const wildcard = [...this.listeners.entries()]
-            .filter(([key]) => key.endsWith("*") && topic.startsWith(key.slice(0, -1)))
+            .filter(([key]) => key.endsWith('*') && topic.startsWith(key.slice(0, -1)))
             .flatMap(([_, handlers]) => [...handlers]);
         return new Set([...exact, ...wildcard]);
     }
@@ -223,27 +243,27 @@ export class EventBusHandler {
      */
     validateTopic(topic) {
         // Split event type into parts
-        const parts = topic.split(".");
+        const parts = topic.split('.');
         const [plugin, area, action] = parts;
         if (parts.length !== 3) {
-            if (parts.length === 1 && plugin === "*") {
+            if (parts.length === 1 && plugin === '*') {
                 return true;
             }
-            if (parts.length === 2 && plugin !== "*" && area === "*") {
+            if (parts.length === 2 && plugin !== '*' && area === '*') {
                 return true;
             }
             this.logAndThrowError(false, `Event type must have 3 parts separated by dots. Received: ` + topic);
             return false;
         }
-        if (action === "*") {
+        if (action === '*') {
             return true;
         }
         // Validate action part
-        const validActions = ["request", "create", "update", "delete", "trigger"];
-        if (validActions.some(a => action.startsWith(a))) {
+        const validActions = ['request', 'create', 'update', 'delete', 'trigger'];
+        if (validActions.some((a) => action.startsWith(a))) {
             return true;
         }
-        this.logAndThrowError(false, `Invalid event topic name. The action: ` + action + ". Must be or start with one of: " + validActions.join(", "));
+        this.logAndThrowError(false, `Invalid event topic name. The action: ` + action + '. Must be or start with one of: ' + validActions.join(', '));
         return false;
     }
     logIfDebug(...args) {

package/dist/fromRimori/PluginTypes.d.ts

@@ -1,9 +1,9 @@
-export type Plugin<T extends {} = {}> = Omit<RimoriPluginConfig<T>, 'context_menu_actions'> & {
+export type Plugin<T extends object = object> = Omit<RimoriPluginConfig<T>, 'context_menu_actions'> & {
     version: string;
     endpoint: string;
     assetEndpoint: string;
     context_menu_actions: MenuEntry[];
-    release_channel: "alpha" | "beta" | "stable";
+    release_channel: 'alpha' | 'beta' | 'stable';
 };
 export type ActivePlugin = Plugin<{
     active?: boolean;
@@ -14,7 +14,7 @@ export interface PluginPage {
     url: string;
     show: boolean;
     description: string;
-    root: "vocabulary" | "grammar" | "reading" | "listening" | "watching" | "writing" | "speaking" | "other" | "community";
+    root: 'vocabulary' | 'grammar' | 'reading' | 'listening' | 'watching' | 'writing' | 'speaking' | 'other' | 'community';
     action?: {
         key: string;
         parameters: ObjectTool;
@@ -46,7 +46,7 @@ export interface ContextMenuAction {
  * Rimori plugin structure representing the complete configuration
  * of a Rimori plugin with all metadata and configuration options.
  */
-export interface RimoriPluginConfig<T extends {} = {}> {
+export interface RimoriPluginConfig<T extends object = object> {
     id: string;
     /**
      * Basic information about the plugin including branding and core details.
@@ -79,7 +79,7 @@ export interface RimoriPluginConfig<T extends {} = {}> {
     /**
      * Context menu actions that the plugin registers to appear in right-click menus throughout the application.
      */
-    context_menu_actions: Omit<MenuEntry, "plugin_id">[];
+    context_menu_actions: Omit<MenuEntry, 'plugin_id'>[];
     /**
      * Documentation paths for different types of plugin documentation.
      */
@@ -107,7 +107,7 @@ export interface Tool {
     parameters: {
         name: string;
         description: string;
-        type: "string" | "number" | "boolean";
+        type: 'string' | 'number' | 'boolean';
     }[];
     execute?: (args: Record<string, any>) => Promise<unknown> | unknown | void;
 }

package/dist/index.d.ts

@@ -11,7 +11,8 @@ export { Translator } from './controller/TranslationController';
 export type { TOptions } from 'i18next';
 export type { SharedContent, SharedContentObjectRequest } from './controller/SharedContentController';
 export type { Exercise } from './controller/ExerciseController';
-export type { UserInfo, Language } from './controller/SettingsController';
+export type { UserInfo, Language, UserRole } from './controller/SettingsController';
 export type { Message, ToolInvocation } from './controller/AIController';
 export type { TriggerAction } from './controller/ExerciseController';
 export type { MacroAccomplishmentPayload, MicroAccomplishmentPayload } from './controller/AccomplishmentController';
+export type { EventBusMessage } from './fromRimori/EventBus';

package/dist/plugin/CommunicationHandler.d.ts

@@ -27,6 +27,17 @@ export interface RimoriInfo {
     mainPanelPlugin?: ActivePlugin;
     sidePanelPlugin?: ActivePlugin;
     interfaceLanguage: string;
+    /**
+     * The release channel of the plugin installation.
+     */
+    releaseChannel: 'alpha' | 'beta' | 'stable';
+    /**
+     * The database schema to use for plugin tables.
+     * Determined by rimori-main based on release channel:
+     * - 'plugins_alpha' for alpha release channel
+     * - 'plugins' for beta and stable release channels
+     */
+    dbSchema: 'plugins' | 'plugins_alpha';
 }
 export declare class RimoriCommunicationHandler {
     private port;

package/dist/plugin/CommunicationHandler.js

@@ -26,15 +26,17 @@ export class RimoriCommunicationHandler {
     }
     initMessageChannel(worker = false) {
         const listener = (event) => {
-            console.log('[PluginController] window message', { origin: event.origin, data: event.data });
+            // 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,
-                });
+                // console.log('[PluginController] message ignored (not init or wrong plugin)', {
+                //   type,
+                //   pluginId,
+                //   currentPluginId: this.pluginId,
+                //   hasPortProperty: !!transferredPort,
+                //   event
+                // });
                 return;
             }
             this.queryParams = queryParams || {};
@@ -182,7 +184,7 @@ export class RimoriCommunicationHandler {
                 else {
                     // In main thread context, use EventBus
                     const { data } = yield EventBus.request(this.pluginId, 'global.supabase.requestAccess');
-                    console.log({ data });
+                    // console.log({ data });
                     this.rimoriInfo = data;
                     this.supabase = createClient(this.rimoriInfo.url, this.rimoriInfo.key, {
                         accessToken: () => Promise.resolve(this.getToken()),

package/dist/plugin/Logger.d.ts

@@ -54,6 +54,7 @@ export declare class Logger {
     private getBrowserInfo;
     /**
      * Capture a screenshot of the current page.
+     * Dynamically imports html2canvas only in browser environments.
      * @returns Promise resolving to base64 screenshot or null if failed
      */
     private captureScreenshot;