@rimori/client 2.4.0-next.4 → 2.4.0-next.6

package/src/plugin/module/AIModule.ts

@@ -0,0 +1,77 @@
+import { RimoriCommunicationHandler, RimoriInfo } from '../CommunicationHandler';
+import { generateText, Message, OnLLMResponse, streamChatGPT } from '../../controller/AIController';
+import { generateObject, ObjectRequest } from '../../controller/ObjectController';
+import { getSTTResponse, getTTSResponse } from '../../controller/VoiceController';
+import { Tool } from '../../fromRimori/PluginTypes';
+
+/**
+ * Controller for AI-related operations.
+ * Provides access to text generation, voice synthesis, and object generation.
+ */
+export class AIModule {
+  private communicationHandler: RimoriCommunicationHandler;
+  private backendUrl: string;
+  private token: string;
+
+  constructor(communicationHandler: RimoriCommunicationHandler, info: RimoriInfo) {
+    this.token = info.token;
+    this.backendUrl = info.backendUrl;
+    this.communicationHandler = communicationHandler;
+
+    this.communicationHandler.onUpdate((updatedInfo) => {
+      this.token = updatedInfo.token;
+    });
+  }
+
+  /**
+   * Generate text from messages using AI.
+   * @param messages The messages to generate text from.
+   * @param tools Optional tools to use for generation.
+   * @returns The generated text.
+   */
+  async getText(messages: Message[], tools?: Tool[]): Promise<string> {
+    return generateText(this.backendUrl, messages, tools || [], this.token).then(
+      ({ messages }) => messages[0].content[0].text,
+    );
+  }
+
+  /**
+   * Stream text generation from messages using AI.
+   * @param messages The messages to generate text from.
+   * @param onMessage Callback for each message chunk.
+   * @param tools Optional tools to use for generation.
+   */
+  async getSteamedText(messages: Message[], onMessage: OnLLMResponse, tools?: Tool[]): Promise<void> {
+    streamChatGPT(this.backendUrl, messages, tools || [], onMessage, this.token);
+  }
+
+  /**
+   * Generate voice audio from text using AI.
+   * @param text The text to convert to voice.
+   * @param voice The voice to use (default: 'alloy').
+   * @param speed The speed of the voice (default: 1).
+   * @param language Optional language for the voice.
+   * @returns The generated audio as a Blob.
+   */
+  async getVoice(text: string, voice = 'alloy', speed = 1, language?: string): Promise<Blob> {
+    return getTTSResponse(this.backendUrl, { input: text, voice, speed, language }, this.token);
+  }
+
+  /**
+   * Convert voice audio to text using AI.
+   * @param file The audio file to convert.
+   * @returns The transcribed text.
+   */
+  async getTextFromVoice(file: Blob): Promise<string> {
+    return getSTTResponse(this.backendUrl, file, this.token);
+  }
+
+  /**
+   * Generate a structured object from a request using AI.
+   * @param request The object generation request.
+   * @returns The generated object.
+   */
+  async getObject<T = any>(request: ObjectRequest): Promise<T> {
+    return generateObject<T>(this.backendUrl, request, this.token);
+  }
+}

package/src/plugin/module/DbModule.ts

@@ -0,0 +1,67 @@
+import { PostgrestClientOptions, PostgrestQueryBuilder } from '@supabase/postgrest-js';
+import { SupabaseClient } from '../CommunicationHandler';
+// import { GenericSchema } from '@supabase/postgrest-js/dist/module/lib/types';
+import { RimoriCommunicationHandler, RimoriInfo } from '../CommunicationHandler';
+import { GenericSchema, GenericTable } from '@supabase/postgrest-js/dist/cjs/types/common/common';
+
+/**
+ * Database module for plugin database operations.
+ * Provides access to plugin tables with automatic prefixing and schema management.
+ */
+export class DbModule {
+  private supabase: SupabaseClient;
+  private rimoriInfo: RimoriInfo;
+  public tablePrefix: string;
+  public schema: string;
+
+  constructor(supabase: SupabaseClient, communicationHandler: RimoriCommunicationHandler, info: RimoriInfo) {
+    this.supabase = supabase;
+    this.rimoriInfo = info;
+    this.tablePrefix = info.tablePrefix;
+    this.schema = info.dbSchema;
+
+    communicationHandler.onUpdate((updatedInfo) => {
+      this.rimoriInfo = updatedInfo;
+      this.tablePrefix = updatedInfo.tablePrefix;
+      this.schema = updatedInfo.dbSchema;
+    });
+  }
+
+  /**
+   * Query a database table.
+   * Global tables (starting with 'global_') remain in public schema.
+   * Plugin tables use the schema provided by rimori-main (plugins or plugins_alpha).
+   * @param relation The table name (without prefix for plugin tables, with 'global_' for global tables).
+   * @returns A Postgrest query builder for the table.
+   */
+  from<ViewName extends string & keyof GenericSchema['Views'], View extends GenericSchema['Views'][ViewName]>(
+    relation: string,
+  ): PostgrestQueryBuilder<PostgrestClientOptions, GenericSchema, GenericTable, ViewName, View> {
+    const tableName = this.getTableName(relation);
+    // Use the schema determined by rimori-main based on release channel
+    // Global tables (starting with 'global_') remain in public schema
+    // Plugin tables use the schema provided by rimori-main (plugins or plugins_alpha)
+    if (relation.startsWith('global_')) {
+      // Global tables stay in public schema
+      return this.supabase.from(tableName);
+    }
+    // Plugin tables go to the schema provided by rimori-main
+    return this.supabase.schema(this.rimoriInfo.dbSchema).from(tableName);
+  }
+
+  /**
+   * Get the table name for a given plugin table.
+   * Internally all tables are prefixed with the plugin id. This function is used to get the correct table name for a given public table.
+   * @param table The plugin table name to get the full table name for.
+   * @returns The full table name.
+   */
+  getTableName(table: string): string {
+    if (/[A-Z]/.test(table)) {
+      throw new Error('Table name cannot include uppercase letters. Please use snake_case for table names.');
+    }
+    if (table.startsWith('global_')) {
+      return table.replace('global_', '');
+    }
+    return this.tablePrefix + '_' + table;
+  }
+}

package/src/plugin/module/EventModule.ts

@@ -0,0 +1,192 @@
+import { MainPanelAction } from '../../fromRimori/PluginTypes';
+import { AccomplishmentController, AccomplishmentPayload } from '../../controller/AccomplishmentController';
+import { EventBus, EventBusMessage, EventHandler, EventPayload, EventListener } from '../../fromRimori/EventBus';
+
+/**
+ * Event module for plugin event bus operations.
+ * Provides methods for emitting, listening to, and responding to events.
+ */
+export class EventModule {
+  private pluginId: string;
+  private accomplishmentController: AccomplishmentController;
+
+  constructor(pluginId: string) {
+    this.pluginId = pluginId;
+    this.accomplishmentController = new AccomplishmentController(pluginId);
+  }
+
+  public getGlobalEventTopic(preliminaryTopic: string): string {
+    if (preliminaryTopic.startsWith('global.')) {
+      return preliminaryTopic;
+    }
+    if (preliminaryTopic.startsWith('self.')) {
+      return preliminaryTopic;
+    }
+    const topicParts = preliminaryTopic.split('.');
+    if (topicParts.length === 3) {
+      if (!topicParts[0].startsWith('pl') && topicParts[0] !== 'global') {
+        throw new Error("The event topic must start with the plugin id or 'global'.");
+      }
+      return preliminaryTopic;
+    } else if (topicParts.length > 3) {
+      throw new Error(
+        `The event topic must consist of 3 parts. <pluginId>.<topic area>.<action>. Received: ${preliminaryTopic}`,
+      );
+    }
+
+    const topicRoot = this.pluginId ?? 'global';
+    return `${topicRoot}.${preliminaryTopic}`;
+  }
+
+  /**
+   * Emit an event to Rimori or a plugin.
+   * The topic schema is:
+   * {pluginId}.{eventId}
+   * Check out the event bus documentation for more information.
+   * For triggering events from Rimori like context menu actions use the "global" keyword.
+   * @param topic The topic to emit the event on.
+   * @param data The data to emit.
+   * @param eventId The event id.
+   */
+  emit(topic: string, data?: any, eventId?: number): void {
+    const globalTopic = this.getGlobalEventTopic(topic);
+    EventBus.emit(this.pluginId, globalTopic, data, eventId);
+  }
+
+  /**
+   * Request an event.
+   * @param topic The topic to request the event on.
+   * @param data The data to request.
+   * @returns The response from the event.
+   */
+  request<T>(topic: string, data?: any): Promise<EventBusMessage<T>> {
+    const globalTopic = this.getGlobalEventTopic(topic);
+    return EventBus.request<T>(this.pluginId, globalTopic, data);
+  }
+
+  /**
+   * Subscribe to an event.
+   * @param topic The topic to subscribe to.
+   * @param callback The callback to call when the event is emitted.
+   * @returns An EventListener object containing an off() method to unsubscribe the listeners.
+   */
+  on<T = EventPayload>(topic: string | string[], callback: EventHandler<T>): EventListener {
+    const topics = Array.isArray(topic) ? topic : [topic];
+    return EventBus.on<T>(
+      topics.map((t) => this.getGlobalEventTopic(t)),
+      callback,
+    );
+  }
+
+  /**
+   * Subscribe to an event once.
+   * @param topic The topic to subscribe to.
+   * @param callback The callback to call when the event is emitted.
+   */
+  once<T = EventPayload>(topic: string, callback: EventHandler<T>): void {
+    EventBus.once<T>(this.getGlobalEventTopic(topic), callback);
+  }
+
+  /**
+   * Respond to an event.
+   * @param topic The topic to respond to.
+   * @param data The data to respond with.
+   */
+  respond<T = EventPayload>(
+    topic: string | string[],
+    data: EventPayload | ((data: EventBusMessage<T>) => EventPayload | Promise<EventPayload>),
+  ): void {
+    const topics = Array.isArray(topic) ? topic : [topic];
+    EventBus.respond(
+      this.pluginId,
+      topics.map((t) => this.getGlobalEventTopic(t)),
+      data,
+    );
+  }
+
+  /**
+   * Emit an accomplishment.
+   * @param payload The payload to emit.
+   */
+  emitAccomplishment(payload: AccomplishmentPayload): void {
+    this.accomplishmentController.emitAccomplishment(payload);
+  }
+
+  /**
+   * Subscribe to an accomplishment.
+   * @param accomplishmentTopic The topic to subscribe to.
+   * @param callback The callback to call when the accomplishment is emitted.
+   */
+  onAccomplishment(
+    accomplishmentTopic: string,
+    callback: (payload: EventBusMessage<AccomplishmentPayload>) => void,
+  ): void {
+    this.accomplishmentController.subscribe(accomplishmentTopic, callback);
+  }
+
+  /**
+   * Trigger an action that opens the sidebar and triggers an action in the designated plugin.
+   * @param pluginId The id of the plugin to trigger the action for.
+   * @param actionKey The key of the action to trigger.
+   * @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 {
+    this.emit('global.sidebar.triggerAction', { plugin_id: pluginId, action_key: actionKey, text });
+  }
+
+  /**
+   * Subscribe to main panel actions triggered by the user from the dashboard.
+   * @param callback Handler function that receives the action data when a matching action is triggered.
+   * @param actionsToListen Optional filter to listen only to specific action keys. If empty or not provided, all actions will trigger the callback.
+   * @returns An EventListener object with an `off()` method for cleanup.
+   *
+   * @example
+   * ```ts
+   * const listener = client.event.onMainPanelAction((data) => {
+   *   console.log('Action received:', data.action_key);
+   * }, ['startSession', 'pauseSession']);
+   *
+   * // Clean up when component unmounts to prevent events from firing
+   * // when navigating away or returning to the page
+   * useEffect(() => {
+   *   return () => listener.off();
+   * }, []);
+   * ```
+   *
+   * **Important:** Always call `listener.off()` when your component unmounts or when you no longer need to listen.
+   * This prevents the event handler from firing when navigating away from or returning to the page, which could
+   * cause unexpected behavior or duplicate event handling.
+   */
+  onMainPanelAction(callback: (data: MainPanelAction) => void, actionsToListen: string | string[] = []): EventListener {
+    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.requestMain');
+    return this.on<MainPanelAction>('action.requestMain', ({ data }) => {
+      // console.log('Received action for main panel ' + data.action_key);
+      // console.log('Listening to actions', listeningActions);
+      if (listeningActions.length === 0 || listeningActions.includes(data.action_key)) {
+        callback(data);
+      }
+    });
+  }
+
+  /**
+   * Subscribe to side panel actions triggered by the user from the dashboard.
+   * @param callback Handler function that receives the action data when a matching action is triggered.
+   * @param actionsToListen Optional filter to listen only to specific action keys. If empty or not provided, all actions will trigger the callback.
+   * @returns An EventListener object with an `off()` method for cleanup.
+   */
+  onSidePanelAction(callback: (data: MainPanelAction) => void, actionsToListen: string | string[] = []): EventListener {
+    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<MainPanelAction>('action.requestSidebar', ({ data }) => {
+      // console.log("eventHandler .onSidePanelAction", data);
+      // console.log('Received action for sidebar ' + data.action);
+      // console.log('Listening to actions', listeningActions);
+      if (listeningActions.length === 0 || listeningActions.includes(data.action)) {
+        callback(data);
+      }
+    });
+  }
+}

package/src/{controller/ExerciseController.ts → plugin/module/ExerciseModule.ts}

@@ -1,5 +1,6 @@
-import { SupabaseClient } from '@supabase/supabase-js';
-import { RimoriClient } from '../plugin/RimoriClient';
+import { SupabaseClient } from '../CommunicationHandler';
+import { RimoriCommunicationHandler, RimoriInfo } from '../CommunicationHandler';
+import { EventModule } from './EventModule';
 
 export type TriggerAction = { action_key: string } & Record<string, string | number | boolean>;
 
@@ -20,7 +21,6 @@ export interface Exercise {
   start_date: string;
   end_date: string;
   trigger_action: TriggerAction;
-  // topic that identifies the accomplishment that the exercise is related to
   achievement_topic: string;
   name: string;
   description: string;
@@ -29,13 +29,32 @@ export interface Exercise {
   updated_at?: string;
 }
 
-export class ExerciseController {
+/**
+ * Controller for exercise-related operations.
+ * Provides access to weekly exercises and exercise management.
+ */
+export class ExerciseModule {
   private supabase: SupabaseClient;
-  private rimoriClient: RimoriClient;
-
-  constructor(supabase: SupabaseClient, rimoriClient: RimoriClient) {
+  private communicationHandler: RimoriCommunicationHandler;
+  private eventModule: EventModule;
+  private backendUrl: string;
+  private token: string;
+
+  constructor(
+    supabase: SupabaseClient,
+    communicationHandler: RimoriCommunicationHandler,
+    info: RimoriInfo,
+    eventModule: EventModule,
+  ) {
     this.supabase = supabase;
-    this.rimoriClient = rimoriClient;
+    this.communicationHandler = communicationHandler;
+    this.eventModule = eventModule;
+    this.token = info.token;
+    this.backendUrl = info.backendUrl;
+
+    this.communicationHandler.onUpdate((updatedInfo) => {
+      this.token = updatedInfo.token;
+    });
   }
 
   /**
@@ -43,7 +62,7 @@ export class ExerciseController {
    * Shows exercises for the current week that haven't expired.
    * @returns Array of exercise objects.
    */
-  public async viewWeeklyExercises(): Promise<Exercise[]> {
+  async view(): Promise<Exercise[]> {
     const { data, error } = await this.supabase.from('weekly_exercises').select('*');
 
     if (error) {
@@ -54,21 +73,21 @@ export class ExerciseController {
   }
 
   /**
-   * Creates multiple exercises via the backend API.
-   * All requests are made in parallel but only one event is emitted.
-   * @param token The token to use for authentication.
-   * @param backendUrl The URL of the backend API.
-   * @param exercises Exercise creation parameters.
+   * Creates a new exercise or multiple exercises via the backend API.
+   * When creating multiple exercises, all requests are made in parallel but only one event is emitted.
+   * @param params Exercise creation parameters (single or array).
    * @returns Created exercise objects.
    */
-  public async addExercise(token: string, backendUrl: string, exercises: CreateExerciseParams[]): Promise<Exercise[]> {
+  async add(params: CreateExerciseParams | CreateExerciseParams[]): Promise<Exercise[]> {
+    const exercises = Array.isArray(params) ? params : [params];
+
     const responses = await Promise.all(
       exercises.map(async (exercise) => {
-        const response = await fetch(`${backendUrl}/exercises`, {
+        const response = await fetch(`${this.backendUrl}/exercises`, {
           method: 'POST',
           headers: {
             'Content-Type': 'application/json',
-            Authorization: `Bearer ${token}`,
+            Authorization: `Bearer ${this.token}`,
           },
           body: JSON.stringify(exercise),
         });
@@ -82,27 +101,21 @@ export class ExerciseController {
       }),
     );
 
-    this.rimoriClient.event.emit('global.exercises.triggerChange');
+    this.eventModule.emit('global.exercises.triggerChange');
 
     return responses;
   }
 
   /**
    * Deletes an exercise via the backend API.
-   * @param token The token to use for authentication.
-   * @param backendUrl The URL of the backend API.
-   * @param exerciseId The exercise ID to delete.
+   * @param id The exercise ID to delete.
    * @returns Success status.
    */
-  public async deleteExercise(
-    token: string,
-    backendUrl: string,
-    id: string,
-  ): Promise<{ success: boolean; message: string }> {
-    const response = await fetch(`${backendUrl}/exercises/${id}`, {
+  async delete(id: string): Promise<{ success: boolean; message: string }> {
+    const response = await fetch(`${this.backendUrl}/exercises/${id}`, {
       method: 'DELETE',
       headers: {
-        Authorization: `Bearer ${token}`,
+        Authorization: `Bearer ${this.token}`,
       },
     });
 
@@ -110,7 +123,8 @@ export class ExerciseController {
       const errorText = await response.text();
       throw new Error(`Failed to delete exercise: ${errorText}`);
     }
-    this.rimoriClient.event.emit('global.exercises.triggerChange');
+
+    this.eventModule.emit('global.exercises.triggerChange');
 
     return await response.json();
   }

package/src/plugin/module/PluginModule.ts

@@ -0,0 +1,114 @@
+import { SettingsController, UserInfo } from '../../controller/SettingsController';
+import { RimoriCommunicationHandler, RimoriInfo } from '../CommunicationHandler';
+import { Translator } from '../../controller/TranslationController';
+import { ActivePlugin, Plugin } from '../../fromRimori/PluginTypes';
+import { SupabaseClient } from '../CommunicationHandler';
+
+type Theme = 'light' | 'dark';
+type ApplicationMode = 'main' | 'sidebar' | 'settings';
+/**
+ * Controller for plugin-related operations.
+ * Provides access to plugin settings, user info, and plugin information.
+ */
+export class PluginModule {
+  private settingsController: SettingsController;
+  private communicationHandler: RimoriCommunicationHandler;
+  private translator: Translator;
+  private rimoriInfo: RimoriInfo;
+  public pluginId: string;
+  /**
+   * The release channel of this plugin installation.
+   * Determines which database schema is used for plugin tables.
+   */
+  public releaseChannel: string;
+  public applicationMode: ApplicationMode;
+  public theme: Theme;
+
+  constructor(supabase: SupabaseClient, communicationHandler: RimoriCommunicationHandler, info: RimoriInfo) {
+    this.rimoriInfo = info;
+    this.communicationHandler = communicationHandler;
+    this.pluginId = info.pluginId;
+    this.releaseChannel = info.releaseChannel;
+
+    this.settingsController = new SettingsController(supabase, info.pluginId, info.guild);
+
+    const currentPlugin = info.installedPlugins.find((plugin) => plugin.id === info.pluginId);
+    this.translator = new Translator(info.interfaceLanguage, currentPlugin?.endpoint || '');
+
+    this.communicationHandler.onUpdate((updatedInfo) => (this.rimoriInfo = updatedInfo));
+    this.applicationMode = this.communicationHandler.getQueryParam('applicationMode') as ApplicationMode;
+    this.theme = (this.communicationHandler.getQueryParam('rm_theme') as Theme) || 'light';
+  }
+
+  /**
+   * Set the settings for the plugin.
+   * @param settings The settings to set.
+   */
+  async setSettings(settings: any): Promise<void> {
+    await this.settingsController.setSettings(settings);
+  }
+
+  /**
+   * Get the settings for the plugin. T can be any type of settings, UserSettings or SystemSettings.
+   * @param defaultSettings The default settings to use if no settings are found.
+   * @returns The settings for the plugin.
+   */
+  async getSettings<T extends object>(defaultSettings: T): Promise<T> {
+    return await this.settingsController.getSettings<T>(defaultSettings);
+  }
+
+  /**
+   * Get the current user info.
+   * Note: For reactive updates in React components, use the userInfo from useRimori() hook instead.
+   * @returns The user info.
+   */
+  getUserInfo(): UserInfo {
+    return this.rimoriInfo.profile;
+  }
+
+  /**
+   * Register a callback to be notified when RimoriInfo is updated.
+   * This is useful for reacting to changes in user info, tokens, or other rimori data.
+   * @param callback - Function to call with the new RimoriInfo
+   * @returns Cleanup function to unregister the callback
+   */
+  onRimoriInfoUpdate(callback: (info: RimoriInfo) => void): () => void {
+    return this.communicationHandler.onUpdate(callback);
+  }
+
+  /**
+   * 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;
+  } {
+    return {
+      installedPlugins: this.rimoriInfo.installedPlugins,
+      mainPanelPlugin: this.rimoriInfo.mainPanelPlugin,
+      sidePanelPlugin: this.rimoriInfo.sidePanelPlugin,
+    };
+  }
+
+  /**
+   * Get the translator for the plugin.
+   * @returns The translator for the plugin.
+   */
+  async getTranslator(): Promise<Translator> {
+    await this.translator.initialize();
+    return this.translator;
+  }
+}