@rimori/client 2.5.29-next.0 → 2.5.29-next.1

package/dist/controller/AccomplishmentController.d.ts

@@ -1,4 +1,4 @@
-import { EventBusMessage } from '../fromRimori/EventBus';
+import { EventBusHandler, EventBusMessage } from '../fromRimori/EventBus';
 export type AccomplishmentMessage = EventBusMessage<MicroAccomplishmentPayload>;
 export declare const skillCategories: readonly ["reading", "listening", "speaking", "writing", "learning", "community"];
 interface BaseAccomplishmentPayload {
@@ -23,7 +23,8 @@ export interface MacroAccomplishmentPayload extends BaseAccomplishmentPayload {
 export type AccomplishmentPayload = MicroAccomplishmentPayload | MacroAccomplishmentPayload;
 export declare class AccomplishmentController {
     private pluginId;
-    constructor(pluginId: string);
+    private eventBus;
+    constructor(pluginId: string, eventBus?: EventBusHandler);
     emitAccomplishment(payload: Omit<AccomplishmentPayload, 'type'>): void;
     private validateAccomplishment;
     private sanitizeAccomplishment;

package/dist/controller/AccomplishmentController.js

@@ -1,8 +1,9 @@
 import { EventBus } from '../fromRimori/EventBus';
 export const skillCategories = ['reading', 'listening', 'speaking', 'writing', 'learning', 'community'];
 export class AccomplishmentController {
-    constructor(pluginId) {
+    constructor(pluginId, eventBus) {
         this.pluginId = pluginId;
+        this.eventBus = eventBus !== null && eventBus !== void 0 ? eventBus : EventBus;
     }
     emitAccomplishment(payload) {
         const accomplishmentPayload = Object.assign(Object.assign({}, payload), { type: 'durationMinutes' in payload ? 'macro' : 'micro' });
@@ -11,7 +12,7 @@ export class AccomplishmentController {
         }
         const sanitizedPayload = this.sanitizeAccomplishment(accomplishmentPayload);
         const topic = 'global.accomplishment.trigger' + (accomplishmentPayload.type === 'macro' ? 'Macro' : 'Micro');
-        EventBus.emit(this.pluginId, topic, sanitizedPayload);
+        this.eventBus.emit(this.pluginId, topic, sanitizedPayload);
     }
     validateAccomplishment(payload) {
         if (!skillCategories.includes(payload.skillCategory)) {
@@ -85,7 +86,7 @@ export class AccomplishmentController {
             else if (topicLength !== 3) {
                 throw new Error('Invalid accomplishment topic pattern. The pattern must be plugin.skillCategory.accomplishmentKeyword or an * as wildcard for any plugin, skill category or accomplishment keyword');
             }
-            EventBus.on(['global.accomplishment.triggerMicro', 'global.accomplishment.triggerMacro'], (event) => {
+            this.eventBus.on(['global.accomplishment.triggerMicro', 'global.accomplishment.triggerMacro'], (event) => {
                 const { plugin, skillCategory, accomplishmentKeyword } = this.getDecoupledTopic(accomplishmentTopic);
                 if (plugin !== '*' && event.sender !== plugin)
                     return;

package/dist/controller/TranslationController.js

@@ -79,12 +79,13 @@ export class Translator {
         });
     }
     getTranslationUrl(language) {
+        const baseUrl = this.translationUrl || window.location.origin;
         // For localhost development, use local- prefix for non-English languages
-        if (window.location.hostname === 'localhost') {
+        if (window.location.hostname === 'localhost' || new URL(baseUrl).hostname === 'localhost') {
             const filename = language !== 'en' ? `local-${language}` : language;
-            return `${window.location.origin}/locales/${filename}.json`;
+            return `${baseUrl}/locales/${filename}.json`;
         }
-        return `${this.translationUrl}/locales/${language}.json`;
+        return `${baseUrl}/locales/${language}.json`;
     }
     usePlugin(plugin) {
         if (!this.i18n) {

package/dist/fromRimori/EventBus.d.ts

@@ -29,6 +29,11 @@ export declare class EventBusHandler {
     private generatedIds;
     private cleanupInterval;
     private constructor();
+    /**
+     * Creates a new non-singleton EventBusHandler instance.
+     * Used in federation mode where each plugin needs its own isolated EventBus.
+     */
+    static create(name?: string): EventBusHandler;
     static getInstance(name?: string): EventBusHandler;
     /**
      * Starts the interval to cleanup the generated ids.
@@ -109,6 +114,10 @@ export declare class EventBusHandler {
      */
     private validateTopic;
     private logIfDebug;
+    /**
+     * Destroys this EventBus instance, cleaning up all listeners and intervals.
+     */
+    destroy(): void;
     private logAndThrowError;
 }
 export declare const EventBus: EventBusHandler;

package/dist/fromRimori/EventBus.js

@@ -15,9 +15,18 @@ export class EventBusHandler {
         this.evName = '';
         this.generatedIds = new Map(); // Map<id, timestamp>
         this.cleanupInterval = null;
-        //private constructor
         this.startIdCleanup();
     }
+    /**
+     * Creates a new non-singleton EventBusHandler instance.
+     * Used in federation mode where each plugin needs its own isolated EventBus.
+     */
+    static create(name) {
+        const instance = new EventBusHandler();
+        if (name)
+            instance.evName = name;
+        return instance;
+    }
     static getInstance(name) {
         if (!EventBusHandler.instance) {
             EventBusHandler.instance = new EventBusHandler();
@@ -307,6 +316,18 @@ export class EventBusHandler {
             console.debug(`[${this.evName}] ` + args[0], ...args.slice(1));
         }
     }
+    /**
+     * Destroys this EventBus instance, cleaning up all listeners and intervals.
+     */
+    destroy() {
+        this.listeners.clear();
+        this.responseResolvers.clear();
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.generatedIds.clear();
+    }
     logAndThrowError(throwError, ...args) {
         const message = `[${this.evName}] ` + args[0];
         console.error(message, ...args.slice(1));

package/dist/fromRimori/PluginTypes.d.ts

@@ -86,6 +86,8 @@ export interface RimoriPluginConfig<T extends object = object> {
         sidebar: (SidebarPage & T)[];
         /** Optional path to the plugin's settings/configuration page */
         settings?: string;
+        /** When true, rimori-main loads this plugin via Module Federation instead of an iframe. */
+        federated?: boolean;
         /** Optional array of event topics the plugin pages can listen to for cross-plugin communication */
         topics?: string[];
     };

package/dist/plugin/CommunicationHandler.d.ts

@@ -67,8 +67,9 @@ export declare class RimoriCommunicationHandler {
     /**
      * Handles updates to RimoriInfo from rimori-main.
      * Updates the cached info and Supabase client, then notifies all registered callbacks.
+     * Public so that federated mode can call it when the update event arrives via the plugin's isolated EventBus.
      */
-    private handleRimoriInfoUpdate;
+    handleRimoriInfoUpdate(newInfo: RimoriInfo): void;
     /**
      * Registers a callback to be called when RimoriInfo is updated.
      * @param callback - Function to call with the new RimoriInfo

package/dist/plugin/CommunicationHandler.js

@@ -77,7 +77,7 @@ export class RimoriCommunicationHandler {
             // Listen for updates from rimori-main (data changes, token refresh, etc.)
             // Topic format: {pluginId}.supabase.triggerUpdate
             EventBus.on(`${this.pluginId}.supabase.triggerUpdate`, (ev) => {
-                // console.log('[RimoriCommunicationHandler] Received update from rimori-main', ev.data);
+                // console.log('[RimoriCommunicationHandler] Received triggerUpdate via MessageChannel for', this.pluginId);
                 this.handleRimoriInfoUpdate(ev.data);
             });
             // Mark MessageChannel as ready and process pending requests
@@ -205,12 +205,14 @@ export class RimoriCommunicationHandler {
     /**
      * Handles updates to RimoriInfo from rimori-main.
      * Updates the cached info and Supabase client, then notifies all registered callbacks.
+     * Public so that federated mode can call it when the update event arrives via the plugin's isolated EventBus.
      */
     handleRimoriInfoUpdate(newInfo) {
         if (JSON.stringify(this.rimoriInfo) === JSON.stringify(newInfo)) {
-            // console.log('[RimoriCommunicationHandler] RimoriInfo update is the same as the cached info, skipping update');
+            // console.log('[RimoriCommunicationHandler] RimoriInfo update identical to cached info, skipping', this.pluginId);
             return;
         }
+        // console.log('[RimoriCommunicationHandler] Applying RimoriInfo update for', this.pluginId, '| ttsEnabled:', newInfo.ttsEnabled);
         // Update cached rimoriInfo
         this.rimoriInfo = newInfo;
         // Update Supabase client with new token

package/dist/plugin/RimoriClient.d.ts

@@ -1,10 +1,12 @@
 import { SharedContentController } from './module/SharedContentController';
+import { RimoriInfo } from './CommunicationHandler';
 import { PluginModule } from './module/PluginModule';
 import { DbModule } from './module/DbModule';
 import { EventModule } from './module/EventModule';
 import { AIModule } from './module/AIModule';
 import { ExerciseModule } from './module/ExerciseModule';
 import { StorageModule } from './module/StorageModule';
+import { EventBusHandler } from '../fromRimori/EventBus';
 export declare class RimoriClient {
     private static instance;
     sharedContent: SharedContentController;
@@ -16,7 +18,15 @@ export declare class RimoriClient {
     /** Upload and manage images stored in Supabase via the backend. */
     storage: StorageModule;
     private rimoriInfo;
+    /** The EventBus instance used by this client. In federation mode this is a per-plugin instance. */
+    eventBus: EventBusHandler;
     private constructor();
+    /**
+     * Creates a RimoriClient with pre-existing RimoriInfo (federation mode).
+     * Uses a fresh per-plugin EventBus instance instead of the global singleton.
+     * Creates the Supabase PostgrestClient internally from the info.
+     */
+    static createWithInfo(info: RimoriInfo): RimoriClient;
     static getInstance(pluginId?: string): Promise<RimoriClient>;
     navigation: {
         toDashboard: () => void;

package/dist/plugin/RimoriClient.js

@@ -16,9 +16,10 @@ import { EventModule } from './module/EventModule';
 import { AIModule } from './module/AIModule';
 import { ExerciseModule } from './module/ExerciseModule';
 import { StorageModule } from './module/StorageModule';
-import { EventBus } from '../fromRimori/EventBus';
+import { PostgrestClient } from '@supabase/postgrest-js';
+import { EventBus, EventBusHandler } from '../fromRimori/EventBus';
 export class RimoriClient {
-    constructor(controller, supabase, info) {
+    constructor(controller, supabase, info, eventBus) {
         this.navigation = {
             toDashboard: () => {
                 this.event.emit('global.navigation.triggerToDashboard');
@@ -30,12 +31,13 @@ export class RimoriClient {
             }),
         };
         this.rimoriInfo = info;
+        this.eventBus = eventBus !== null && eventBus !== void 0 ? eventBus : EventBus;
         this.sharedContent = new SharedContentController(supabase, this);
         this.ai = new AIModule(info.backendUrl, () => this.rimoriInfo.token, info.pluginId);
         this.ai.setOnRateLimited((exercisesRemaining) => {
-            EventBus.emit(info.pluginId, 'global.quota.triggerExceeded', { exercises_remaining: exercisesRemaining });
+            this.eventBus.emit(info.pluginId, 'global.quota.triggerExceeded', { exercises_remaining: exercisesRemaining });
         });
-        this.event = new EventModule(info.pluginId, info.backendUrl, () => this.rimoriInfo.token, this.ai);
+        this.event = new EventModule(info.pluginId, info.backendUrl, () => this.rimoriInfo.token, this.ai, this.eventBus);
         this.db = new DbModule(supabase, controller, info);
         this.plugin = new PluginModule(supabase, controller, info, this.ai);
         this.exercise = new ExerciseModule(supabase, controller, info, this.event);
@@ -48,6 +50,32 @@ export class RimoriClient {
             Logger.getInstance(this);
         }
     }
+    /**
+     * Creates a RimoriClient with pre-existing RimoriInfo (federation mode).
+     * Uses a fresh per-plugin EventBus instance instead of the global singleton.
+     * Creates the Supabase PostgrestClient internally from the info.
+     */
+    static createWithInfo(info) {
+        const eventBus = EventBusHandler.create('Plugin EventBus ' + info.pluginId);
+        const controller = new RimoriCommunicationHandler(info.pluginId, true);
+        const supabase = new PostgrestClient(`${info.url}/rest/v1`, {
+            schema: info.dbSchema,
+            headers: {
+                apikey: info.key,
+                Authorization: `Bearer ${info.token}`,
+            },
+        });
+        const client = new RimoriClient(controller, supabase, info, eventBus);
+        // In federated mode, CommunicationHandler skips MessageChannel setup so it never
+        // subscribes to triggerUpdate events. PluginEventBridge forwards host-bus events to
+        // this plugin's isolated eventBus, so we listen here and hand off to the controller.
+        eventBus.on(`${info.pluginId}.supabase.triggerUpdate`, (ev) => {
+            var _a;
+            console.log('[RimoriClient] Federated triggerUpdate received for', info.pluginId, '| ttsEnabled:', (_a = ev.data) === null || _a === void 0 ? void 0 : _a.ttsEnabled);
+            controller.handleRimoriInfoUpdate(ev.data);
+        });
+        return client;
+    }
     static getInstance(pluginId) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!RimoriClient.instance) {

package/dist/plugin/module/EventModule.d.ts

@@ -1,6 +1,6 @@
 import { MainPanelAction, SidebarAction } from '../../fromRimori/PluginTypes';
 import { AccomplishmentPayload } from '../../controller/AccomplishmentController';
-import { EventBusMessage, EventHandler, EventPayload, EventListener } from '../../fromRimori/EventBus';
+import { EventBusHandler, EventBusMessage, EventHandler, EventPayload, EventListener } from '../../fromRimori/EventBus';
 import { AIModule } from './AIModule';
 /**
  * Event module for plugin event bus operations.
@@ -12,7 +12,8 @@ export declare class EventModule {
     private aiModule;
     private backendUrl;
     private getToken;
-    constructor(pluginId: string, backendUrl: string, getToken: () => string, aiModule: AIModule);
+    private eventBus;
+    constructor(pluginId: string, backendUrl: string, getToken: () => string, aiModule: AIModule, eventBus?: EventBusHandler);
     getGlobalEventTopic(preliminaryTopic: string): string;
     /**
      * Emit an event to Rimori or a plugin.

package/dist/plugin/module/EventModule.js

@@ -14,12 +14,13 @@ import { EventBus } from '../../fromRimori/EventBus';
  * Provides methods for emitting, listening to, and responding to events.
  */
 export class EventModule {
-    constructor(pluginId, backendUrl, getToken, aiModule) {
+    constructor(pluginId, backendUrl, getToken, aiModule, eventBus) {
         this.pluginId = pluginId;
         this.backendUrl = backendUrl;
         this.getToken = getToken;
         this.aiModule = aiModule;
-        this.accomplishmentController = new AccomplishmentController(pluginId);
+        this.eventBus = eventBus !== null && eventBus !== void 0 ? eventBus : EventBus;
+        this.accomplishmentController = new AccomplishmentController(pluginId, this.eventBus);
     }
     getGlobalEventTopic(preliminaryTopic) {
         var _a;
@@ -54,7 +55,7 @@ export class EventModule {
      */
     emit(topic, data, eventId) {
         const globalTopic = this.getGlobalEventTopic(topic);
-        EventBus.emit(this.pluginId, globalTopic, data, eventId);
+        this.eventBus.emit(this.pluginId, globalTopic, data, eventId);
     }
     /**
      * Request an event.
@@ -68,7 +69,7 @@ export class EventModule {
             const globalTopic = this.getGlobalEventTopic(topic);
             yield this.aiModule.session.ensure();
             const sessionToken = (_a = this.aiModule.session.get()) !== null && _a !== void 0 ? _a : undefined;
-            return EventBus.request(this.pluginId, globalTopic, data, sessionToken);
+            return this.eventBus.request(this.pluginId, globalTopic, data, sessionToken);
         });
     }
     /**
@@ -79,7 +80,7 @@ export class EventModule {
      */
     on(topic, callback) {
         const topics = Array.isArray(topic) ? topic : [topic];
-        return EventBus.on(topics.map((t) => this.getGlobalEventTopic(t)), (event) => {
+        return this.eventBus.on(topics.map((t) => this.getGlobalEventTopic(t)), (event) => {
             if (event.ai_session_token && !this.aiModule.session.get()) {
                 this.aiModule.session.set(event.ai_session_token);
             }
@@ -92,7 +93,7 @@ export class EventModule {
      * @param callback The callback to call when the event is emitted.
      */
     once(topic, callback) {
-        EventBus.once(this.getGlobalEventTopic(topic), callback);
+        this.eventBus.once(this.getGlobalEventTopic(topic), callback);
     }
     /**
      * Respond to an event.
@@ -124,7 +125,7 @@ export class EventModule {
                 }
             });
         }
-        EventBus.respond(this.pluginId, topics.map((t) => this.getGlobalEventTopic(t)), wrappedData);
+        this.eventBus.respond(this.pluginId, topics.map((t) => this.getGlobalEventTopic(t)), wrappedData);
     }
     /**
      * Emit an accomplishment.
@@ -219,15 +220,21 @@ export class EventModule {
      */
     onSidePanelAction(callback, actionsToListen = []) {
         const listeningActions = Array.isArray(actionsToListen) ? actionsToListen : [actionsToListen];
-        // this needs to be a emit and on because the main panel action is triggered by the user and not by the plugin
-        this.emit('action.requestSidebar');
-        return this.on('action.requestSidebar', ({ data }) => {
-            // console.log("eventHandler .onSidePanelAction", data);
-            // console.log('Received action for sidebar ' + data.action);
-            // console.log('Listening to actions', listeningActions);
+        // Register the listener BEFORE emitting the request, so the synchronous response
+        // from the bridge/responder is captured (emit → bridge outbound → host respond → bridge inbound is synchronous).
+        console.log('[EventModule] onSidePanelAction: setting up listener for', this.pluginId, 'listening to:', listeningActions);
+        const listener = this.on('action.requestSidebar', ({ data }) => {
+            console.log('[EventModule] onSidePanelAction: received event', { data, listeningActions });
             if (listeningActions.length === 0 || listeningActions.includes(data.action)) {
+                console.log('[EventModule] onSidePanelAction: action matched, calling callback');
                 callback(data);
             }
+            else {
+                console.log('[EventModule] onSidePanelAction: action NOT matched. Got:', data.action, 'expected:', listeningActions);
+            }
         });
+        console.log('[EventModule] onSidePanelAction: emitting action.requestSidebar for', this.pluginId);
+        this.emit('action.requestSidebar');
+        return listener;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimori/client",
-  "version": "2.5.29-next.0",
+  "version": "2.5.29-next.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {