@rimori/client 1.2.0 → 1.3.1

package/src/core/controller/SharedContentController.ts

@@ -22,7 +22,11 @@ export class SharedContentController {
    * @param contentType - The type of content to fetch.
    * @param generatorInstructions - The instructions for the generator. The object needs to have a tool property with a topic and keywords property to let a new unique topic be generated.
    * @param filter - An optional filter to apply to the query.
-   * @param privateTopic - An optional flag to indicate if the topic should be private and only be visible to the user.
+   * @param options - Optional options.
+   * @param options.privateTopic - If the topic should be private and only be visible to the user.
+   * @param options.skipDbSave - If true, do not persist a newly generated content to the DB (default false).
+   * @param options.alwaysGenerateNew - If true, always generate a new content even if there is already a content with the same filter.
+   * @param options.excludeIds - Optional list of shared_content ids to exclude from selection.
    * @returns The new shared content.
    */
   public async getNewSharedContent<T>(
@@ -30,56 +34,66 @@ export class SharedContentController {
     generatorInstructions: SharedContentObjectRequest,
     //this filter is there if the content should be filtered additionally by a column and value
     filter?: SharedContentFilter,
-    privateTopic?: boolean,
+    options?: { privateTopic?: boolean, skipDbSave?: boolean, alwaysGenerateNew?: boolean, excludeIds?: string[] },
   ): Promise<SharedContent<T>> {
-    const query = this.supabase.from("shared_content")
-      .select("*, scc:shared_content_completed(id)")
+    let query = this.supabase.from("shared_content")
+      .select("*, scc:shared_content_completed(id, state)")
       .eq('content_type', contentType)
-      .is('scc.id', null)
-      .is('deleted_at', null)
-      .limit(10);
+      .not('scc.state', 'in', '("completed","ongoing","hidden")')
+      .is('deleted_at', null);
+
+    if (options?.excludeIds && options.excludeIds.length > 0) {
+      const excludeIds = options.excludeIds.filter((id) => !id.startsWith('internal-temp-id-'));
+      // Supabase expects raw PostgREST syntax like '("id1","id2")'.
+      const excludeList = `(${excludeIds.map((id) => `"${id}"`).join(',')})`;
+      query = query.not('id', 'in', excludeList);
+    }
 
     if (filter) {
       query.contains('data', filter);
     }
 
-    const { data: newAssignments, error } = await query;
+    const { data: newAssignments, error } = await query.limit(30);
 
     if (error) {
       console.error('error fetching new assignments:', error);
       throw new Error('error fetching new assignments');
     }
 
-    console.log('newAssignments:', newAssignments);
+    // console.log('newAssignments:', newAssignments);
 
-    if (newAssignments.length > 0) {
+    if (!(options?.alwaysGenerateNew) && newAssignments.length > 0) {
       const index = Math.floor(Math.random() * newAssignments.length);
       return newAssignments[index];
     }
 
-    // generate new assignments
-    const fullInstructions = await this.getGeneratorInstructions(contentType, generatorInstructions, filter);
-
-    console.log('fullInstructions:', fullInstructions);
-
-    const instructions = await this.rimoriClient.ai.getObject(fullInstructions);
+    const instructions = await this.generateNewAssignment(contentType, generatorInstructions, filter);
 
     console.log('instructions:', instructions);
 
-    const { data: newAssignment, error: insertError } = await this.supabase.from("shared_content").insert({
-      private: privateTopic,
-      content_type: contentType,
+    //create the shared content object
+    const data: SharedContent<T> = {
+      id: "internal-temp-id-" + Math.random().toString(36).substring(2, 15),
+      contentType,
       title: instructions.title,
       keywords: instructions.keywords.map(({ text }: { text: string }) => text),
       data: { ...instructions, title: undefined, keywords: undefined, ...generatorInstructions.fixedProperties },
-    }).select();
+      privateTopic: options?.privateTopic,
+    }
 
-    if (insertError) {
-      console.error('error inserting new assignment:', insertError);
-      throw new Error('error inserting new assignment');
+    if (options?.skipDbSave) {
+      return data;
     }
 
-    return newAssignment[0];
+    return await this.createSharedContent(data);
+  }
+
+  private async generateNewAssignment(contentType: string, generatorInstructions: SharedContentObjectRequest, filter?: SharedContentFilter): Promise<any> {
+    const fullInstructions = await this.getGeneratorInstructions(contentType, generatorInstructions, filter);
+
+    console.log('fullInstructions:', fullInstructions);
+
+    return await this.rimoriClient.ai.getObject(fullInstructions);
   }
 
   private async getGeneratorInstructions(contentType: string, generatorInstructions: ObjectRequest, filter?: SharedContentFilter): Promise<ObjectRequest> {
@@ -129,7 +143,55 @@ export class SharedContentController {
   }
 
   public async completeSharedContent(contentType: string, assignmentId: string) {
-    await this.supabase.from("shared_content_completed").insert({ content_type: contentType, id: assignmentId });
+    // Idempotent completion: upsert on (id, user_id) so repeated calls don't fail
+    const { error } = await this.supabase
+      .from("shared_content_completed")
+      .upsert({ content_type: contentType, id: assignmentId } as any, { onConflict: 'id' });
+
+    if (error) {
+      console.error('error completing shared content:', error);
+      throw new Error('error completing shared content');
+    }
+  }
+
+  /**
+   * Update state details for a shared content entry in shared_content_completed.
+   * Assumes table has columns: state ('completed'|'ongoing'|'hidden'), reaction ('liked'|'disliked'|null), bookmarked boolean.
+   * Upserts per (id, content_type, user).
+   * @param param
+   * @param param.contentType - The content type.
+   * @param param.id - The shared content id.
+   * @param param.state - The state to set.
+   * @param param.reaction - Optional reaction.
+   * @param param.bookmarked - Optional bookmark flag.
+   */
+  public async updateSharedContentState({
+    contentType,
+    id,
+    state,
+    reaction,
+    bookmarked,
+  }: {
+    contentType: string
+    id: string
+    state?: 'completed' | 'ongoing' | 'hidden'
+    reaction?: 'liked' | 'disliked' | null
+    bookmarked?: boolean
+  }): Promise<void> {
+    const payload: Record<string, unknown> = { content_type: contentType, id };
+    if (state !== undefined) payload.state = state;
+    if (reaction !== undefined) payload.reaction = reaction;
+    if (bookmarked !== undefined) payload.bookmarked = bookmarked;
+
+    // Prefer upsert, fall back to insert/update if upsert not allowed
+    const { error } = await this.supabase
+      .from('shared_content_completed')
+      .upsert(payload as any, { onConflict: 'id' });
+
+    if (error) {
+      console.error('error updating shared content state:', error);
+      throw new Error('error updating shared content state');
+    }
   }
 
   /**

package/src/core/controller/VoiceController.ts

@@ -1,26 +1,31 @@
-import { SupabaseClient } from "@supabase/supabase-js";
+export async function getSTTResponse(backendUrl: string, audio: Blob, token: string) {
+  const formData = new FormData();
+  formData.append('file', audio);
 
-export async function getSTTResponse(supabase: SupabaseClient, audio: Blob) {
-    const formData = new FormData();
-    formData.append('file', audio);
-
-    return await supabase.functions.invoke('speech', { method: 'POST', body: formData }).then(({ data }) => data.text);
+  return await fetch(`${backendUrl}/voice/stt`, {
+    method: 'POST',
+    headers: { 'Authorization': `Bearer ${token}` },
+    body: formData,
+  }).then(r => r.json()).then(r => {
+    // console.log("STT response: ", r);
+    return r.text;
+  });
 }
 
-export async function getTTSResponse(supabaseUrl: string, request: TTSRequest, token: string) {
-    return await fetch(`${supabaseUrl}/functions/v1/speech`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'Authorization': `Bearer ${token}`
-        },
-        body: JSON.stringify(request),
-    }).then(r => r.blob());
+export async function getTTSResponse(backendUrl: string, request: TTSRequest, token: string) {
+  return await fetch(`${backendUrl}/voice/tts`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${token}`
+    },
+    body: JSON.stringify(request),
+  }).then(r => r.blob());
 }
 
 interface TTSRequest {
-    input: string;
-    voice: string;
-    speed: number;
-    language?: string;
+  input: string;
+  voice: string;
+  speed: number;
+  language?: string;
 }

package/src/core/core.ts

@@ -12,4 +12,5 @@ export { SharedContent } from "./controller/SharedContentController";
 export { Message, OnLLMResponse, ToolInvocation } from "./controller/AIController";
 export { MacroAccomplishmentPayload, MicroAccomplishmentPayload } from "../plugin/AccomplishmentHandler";
 export { Tool } from "../fromRimori/PluginTypes";
+export { SharedContentObjectRequest } from "./controller/SharedContentController";
 

package/src/fromRimori/EventBus.ts

@@ -39,7 +39,7 @@ export class EventBusHandler {
   private listeners: Map<string, Set<Listeners<EventPayload>>> = new Map();
   private responseResolvers: Map<number, (value: EventBusMessage<unknown>) => void> = new Map();
   private static instance: EventBusHandler | null = null;
-  private debugEnabled: boolean = true;
+  private debugEnabled: boolean = false;
   private evName: string = "";
 
   private constructor() {

package/src/fromRimori/PluginTypes.ts

@@ -1,5 +1,5 @@
 // whole configuration of a plugin (from the database)
-export type Plugin = Omit<RimoriPluginConfig, 'context_menu_actions'> & {
+export type Plugin<T extends {} = {}> = Omit<RimoriPluginConfig<T>, 'context_menu_actions'> & {
   version: string;
   endpoint: string;
   assetEndpoint: string;
@@ -7,6 +7,8 @@ export type Plugin = Omit<RimoriPluginConfig, 'context_menu_actions'> & {
   release_channel: "alpha" | "beta" | "stable";
 }
 
+export type ActivePlugin = Plugin<{ active?: boolean }>
+
 // browsable page of a plugin
 export interface PluginPage {
   id: string;
@@ -70,7 +72,7 @@ export interface ContextMenuAction {
  * Rimori plugin structure representing the complete configuration
  * of a Rimori plugin with all metadata and configuration options.
  */
-export interface RimoriPluginConfig {
+export interface RimoriPluginConfig<T extends {} = {}> {
   id: string;
   /**
    * Basic information about the plugin including branding and core details.
@@ -92,9 +94,9 @@ export interface RimoriPluginConfig {
     /** Optional external URL where the plugin is hosted instead of the default CDN */
     external_hosted_url?: string;
     /** Array of main plugin pages that appear in the application's main navigation (can be disabled using the 'show' flag) */
-    main: PluginPage[];
+    main: (PluginPage & T)[];
     /** Array of sidebar pages that appear in the sidebar for quick access (can be disabled using the 'show' flag) */
-    sidebar: SidebarPage[];
+    sidebar: (SidebarPage & T)[];
     /** Optional path to the plugin's settings/configuration page */
     settings?: string;
     /** Optional array of event topics the plugin pages can listen to for cross-plugin communication */

package/src/hooks/UseChatHook.ts

@@ -1,15 +1,17 @@
 import React from "react";
 import { Tool } from "../fromRimori/PluginTypes";
-import { usePlugin } from "../providers/PluginProvider";
+import { useRimori } from "../providers/PluginProvider";
 import { Message, ToolInvocation } from "../core/controller/AIController";
 
 export function useChat(tools?: Tool[]) {
   const [messages, setMessages] = React.useState<Message[]>([]);
   const [isLoading, setIsLoading] = React.useState(false);
-  const { ai } = usePlugin();
+  const { ai } = useRimori();
 
   const append = (appendMessages: Message[]) => {
-    ai.getSteamedText([...messages, ...appendMessages], (id, message, finished: boolean, toolInvocations?: ToolInvocation[]) => {
+    const allMessages = [...messages, ...appendMessages];
+    setMessages(allMessages);
+    ai.getSteamedText(allMessages, (id, message, finished: boolean, toolInvocations?: ToolInvocation[]) => {
       const lastMessage = messages[messages.length - 1];
       setIsLoading(!finished);
 
@@ -17,7 +19,7 @@ export function useChat(tools?: Tool[]) {
         lastMessage.content = message;
         setMessages([...messages, lastMessage]);
       } else {
-        setMessages([...messages, ...appendMessages, { id, role: 'assistant', content: message, toolCalls: toolInvocations }]);
+        setMessages([...allMessages, { id, role: 'assistant', content: message, toolCalls: toolInvocations }]);
       }
     }, tools);
   };

package/src/index.ts

@@ -9,3 +9,4 @@ export * from "./utils/PluginUtils";
 export * from "./utils/Language";
 export * from "./fromRimori/PluginTypes";
 export { FirstMessages } from "./components/ai/utils";
+export { AudioController } from "./plugin/AudioController";

package/src/plugin/AudioController.ts

@@ -0,0 +1,58 @@
+import { EventBus } from "../fromRimori/EventBus";
+
+/**
+ * AudioController is a class that provides methods to record audio. It is a wrapper around the Capacitor Voice Recorder plugin. For more information, see https://github.com/tchvu3/capacitor-voice-recorder.
+ * 
+ * @example
+ * const audioController = new AudioController();
+ * await audioController.startRecording();
+ */
+export class AudioController {
+  private pluginId: string;
+
+  constructor(pluginId: string) {
+    this.pluginId = pluginId;
+  }
+
+  /**
+   * Start the recording.
+   * 
+   * @example
+   * const audioController = new AudioController();
+   * await audioController.startRecording();
+   * @returns void
+   */
+  public async startRecording(): Promise<void> {
+    EventBus.emit(this.pluginId, "global.microphone.triggerStartRecording");
+  }
+
+  /**
+   * Stop the recording and return the audio data.
+   * @returns The audio data.
+   * 
+   * @example 
+   * const audioRef = new Audio(`data:${mimeType};base64,${base64Sound}`)
+   * audioRef.oncanplaythrough = () => audioRef.play()
+   * audioRef.load()
+   */
+  public async stopRecording(): Promise<{ recording: Blob, msDuration: number, mimeType: string }> {
+    const result = await EventBus.request<{ recording: Blob, msDuration: number, mimeType: string }>(this.pluginId, "global.microphone.triggerStopRecording");
+
+    return result.data;
+  }
+
+  public async pauseRecording(): Promise<boolean> {
+    const result = await EventBus.request<boolean>(this.pluginId, "global.microphone.triggerPauseRecording");
+    return result.data;
+  }
+
+  public async resumeRecording(): Promise<boolean> {
+    const result = await EventBus.request<boolean>(this.pluginId, "global.microphone.triggerResumeRecording");
+    return result.data;
+  }
+
+  public async getCurrentStatus(): Promise<"RECORDING" | "PAUSED" | "NONE"> {
+    const result = await EventBus.request<"RECORDING" | "PAUSED" | "NONE">(this.pluginId, "global.microphone.triggerGetCurrentStatus");
+    return result.data;
+  }
+}

package/src/plugin/Logger.ts

@@ -0,0 +1,324 @@
+import { RimoriClient } from './RimoriClient';
+import html2canvas from 'html2canvas';
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+interface LogEntry {
+  id: string;
+  timestamp: string;
+  level: LogLevel;
+  message: string;
+  data?: any;
+  context?: {
+    url: string;
+    userAgent: string;
+    browserInfo: BrowserInfo;
+    screenshot?: string;
+    mousePosition?: MousePosition;
+  };
+}
+
+interface BrowserInfo {
+  userAgent: string;
+  language: string;
+  cookieEnabled: boolean;
+  onLine: boolean;
+  screenResolution: string;
+  windowSize: string;
+  timestamp: string;
+}
+
+interface MousePosition {
+  x: number;
+  y: number;
+  timestamp: string;
+}
+
+/**
+ * Singleton Logger class for Rimori client plugins.
+ * Handles all logging levels, production filtering, and log transmission to Rimori.
+ * Overrides console methods globally for seamless integration.
+ */
+export class Logger {
+  private static instance: Logger;
+  private isProduction: boolean;
+  private logs: LogEntry[] = [];
+  private logIdCounter = 0;
+  private originalConsole: {
+    log: typeof console.log;
+    info: typeof console.info;
+    warn: typeof console.warn;
+    error: typeof console.error;
+    debug: typeof console.debug;
+  };
+  private mousePosition: MousePosition | null = null;
+
+  private constructor(rimori: RimoriClient, isProduction?: boolean) {
+    this.isProduction = this.validateIsProduction(isProduction);
+
+    // Store original console methods
+    this.originalConsole = {
+      log: console.log,
+      info: console.info,
+      warn: console.warn,
+      error: console.error,
+      debug: console.debug
+    };
+
+    // Override console methods globally
+    this.overrideConsoleMethods();
+
+    // Track mouse position
+    this.trackMousePosition();
+
+    // Expose logs to global scope for DevTools access
+    this.exposeToDevTools();
+
+    // Set up navigation clearing
+    this.setupNavigationClearing();
+
+    rimori.event.respond('logging.requestPluginLogs', async () => {
+      this.addLogEntry(await this.createLogEntry('info', 'Screenshot capture', undefined, true));
+      const logs = {
+        logs: this.logs,
+        pluginId: rimori.plugin.pluginId,
+        timestamp: new Date().toISOString()
+      }
+      this.logs = [];
+      this.logIdCounter = 0;
+      return logs;
+    });
+  }
+
+  /**
+   * Initialize the Logger singleton and override console methods globally.
+   * @param rimori - Rimori client instance
+   * @param isProduction - Whether the environment is production
+   * @returns Logger instance
+   */
+  public static getInstance(rimori: RimoriClient, isProduction?: boolean): Logger {
+    if (!Logger.instance) {
+      Logger.instance = new Logger(rimori, isProduction);
+    }
+    return Logger.instance;
+  }
+
+  private validateIsProduction(isProduction?: boolean): boolean {
+    if (isProduction !== undefined) {
+      return isProduction;
+    }
+    if (typeof window !== 'undefined' && window.location.href) {
+      return !window.location.href.includes('localhost');
+    }
+    return true;
+  }
+  /**
+   * Expose log access to global scope for DevTools console access.
+   */
+  private exposeToDevTools(): void {
+    if (typeof window !== 'undefined') {
+      // Expose a global function to access logs from DevTools console
+      (window as any).getRimoriLogs = () => this.logs;
+    }
+  }
+
+  /**
+   * Set up navigation event listeners to clear logs on page changes.
+   */
+  private setupNavigationClearing(): void {
+    if (typeof window === 'undefined' || typeof history === 'undefined') return;
+
+    // Clear logs on browser back/forward
+    window.addEventListener('popstate', () => this.logs = []);
+
+    // Override history methods to clear logs on programmatic navigation
+    const originalPushState = history.pushState;
+    const originalReplaceState = history.replaceState;
+
+    history.pushState = (...args) => {
+      originalPushState.apply(history, args);
+      this.logs = [];
+    };
+
+    history.replaceState = (...args) => {
+      originalReplaceState.apply(history, args);
+      this.logs = [];
+    };
+
+    // Listen for URL changes (works with React Router and other SPAs)
+    let currentUrl = window.location.href;
+    const checkUrlChange = () => {
+      if (window.location.href !== currentUrl) {
+        currentUrl = window.location.href;
+        this.logs = [];
+      }
+    };
+
+    // Check for URL changes periodically
+    setInterval(checkUrlChange, 100);
+
+    // Also listen for hash changes (for hash-based routing)
+    window.addEventListener('hashchange', () => this.logs = []);
+  }
+
+  /**
+   * Override console methods globally to capture all console calls.
+   */
+  private overrideConsoleMethods(): void {
+    // Override console.log
+    console.log = (...args: any[]) => {
+      this.originalConsole.log(...args);
+      this.handleConsoleCall('info', args);
+    };
+
+    // Override console.info
+    console.info = (...args: any[]) => {
+      this.originalConsole.info(...args);
+      this.handleConsoleCall('info', args);
+    };
+
+    // Override console.warn
+    console.warn = (...args: any[]) => {
+      this.originalConsole.warn(...args);
+      this.handleConsoleCall('warn', args);
+    };
+
+    // Override console.error
+    console.error = (...args: any[]) => {
+      this.originalConsole.error(...args);
+      this.handleConsoleCall('error', args);
+    };
+
+    // Override console.debug
+    console.debug = (...args: any[]) => {
+      this.originalConsole.debug(...args);
+      this.handleConsoleCall('debug', args);
+    };
+  }
+
+  /**
+   * Track mouse position for screenshot context.
+   */
+  private trackMousePosition(): void {
+    if (typeof window !== 'undefined') {
+      const updateMousePosition = (event: MouseEvent) => {
+        this.mousePosition = {
+          x: event.clientX,
+          y: event.clientY,
+          timestamp: new Date().toISOString()
+        };
+      };
+
+      window.addEventListener('mousemove', updateMousePosition);
+      window.addEventListener('click', updateMousePosition);
+    }
+  }
+
+  /**
+   * Handle console method calls and create log entries.
+   * @param level - Log level
+   * @param args - Console arguments
+   */
+  private async handleConsoleCall(level: LogLevel, args: any[]): Promise<void> {
+    // Skip if this is a production log that shouldn't be stored
+    if (this.isProduction && (level === 'debug' || level === 'info')) {
+      return;
+    }
+
+    // Convert console arguments to message and data
+    const message = args.map(arg =>
+      typeof arg === 'object' ? JSON.stringify(arg) : String(arg)
+    ).join(' ');
+
+    const data = args.length > 1 ? args.slice(1) : undefined;
+
+    const entry = await this.createLogEntry(level, message, data);
+    this.addLogEntry(entry);
+  }
+
+  /**
+   * Get browser and system information for debugging.
+   * @returns Object with browser and system information
+   */
+  private getBrowserInfo(): BrowserInfo {
+    return {
+      userAgent: navigator.userAgent,
+      language: navigator.language,
+      cookieEnabled: navigator.cookieEnabled,
+      onLine: navigator.onLine,
+      screenResolution: `${screen.width}x${screen.height}`,
+      windowSize: `${window.innerWidth}x${window.innerHeight}`,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Capture a screenshot of the current page.
+   * @returns Promise resolving to base64 screenshot or null if failed
+   */
+  private async captureScreenshot(): Promise<string | null> {
+    if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+      const canvas = await html2canvas(document.body);
+      const screenshot = canvas.toDataURL('image/png');
+      // this.originalConsole.log("screenshot captured", screenshot)
+      return screenshot;
+    }
+    return null;
+  }
+
+  /**
+   * Create a log entry with context information.
+   * @param level - Log level
+   * @param message - Log message
+   * @param data - Additional data
+   * @returns Log entry
+   */
+  private async createLogEntry(level: LogLevel, message: string, data?: any, forceScreenshot?: boolean): Promise<LogEntry> {
+    const context: Partial<LogEntry['context']> = {};
+
+    // Add URL if available
+    if (typeof window === 'undefined' || typeof document === 'undefined') {
+      return {
+        id: `log_${++this.logIdCounter}_${Date.now()}`,
+        timestamp: new Date().toISOString(),
+        level,
+        message,
+        data,
+      }
+    }
+
+    context.url = window.location.href;
+
+    // Add browser info (this method now handles worker context internally)
+    context.browserInfo = this.getBrowserInfo();
+    context.userAgent = context.browserInfo.userAgent;
+
+    // Add screenshot and mouse position if level is error or warn
+    if (level === 'error' || level === 'warn' || forceScreenshot) {
+      context.screenshot = await this.captureScreenshot() || undefined;
+      context.mousePosition = this.mousePosition || undefined;
+    }
+
+    return {
+      id: `log_${++this.logIdCounter}_${Date.now()}`,
+      timestamp: new Date().toISOString(),
+      level,
+      message,
+      data,
+      context: context as LogEntry['context']
+    };
+  }
+
+  /**
+   * Add a log entry to the internal log array.
+   * @param entry - Log entry to add
+   */
+  private addLogEntry(entry: LogEntry): void {
+    this.logs.push(entry);
+
+    // Maintain log size limit (1000 entries)
+    if (this.logs.length > 1000) {
+      this.logs = this.logs.slice(-1000);
+    }
+  }
+}