@rimori/client 1.1.9 → 1.2.0

package/src/fromRimori/PluginTypes.ts

@@ -0,0 +1,203 @@
+// whole configuration of a plugin (from the database)
+export type Plugin = Omit<RimoriPluginConfig, 'context_menu_actions'> & {
+  version: string;
+  endpoint: string;
+  assetEndpoint: string;
+  context_menu_actions: MenuEntry[];
+  release_channel: "alpha" | "beta" | "stable";
+}
+
+// browsable page of a plugin
+export interface PluginPage {
+  id: string;
+  name: string;
+  url: string;
+  // Whether the page should be shown in the navbar
+  show: boolean;
+  description: string;
+  root: "vocabulary" | "grammar" | "reading" | "listening" | "watching" | "writing" | "speaking" | "other" | "community";
+  // The actions that can be triggered in the plugin
+  // The key is the action key. The other entries are additional properties needed when triggering the action
+  action?: {
+    key: string;
+    parameters: ObjectTool;
+  }
+}
+
+// a sidebar page of a plugin
+export interface SidebarPage {
+  // identifier of the page. Used to know which page to trigger when clicking on the sidebar
+  id: string;
+  // name of the page. Shown in the settings
+  name: string;
+  // description of the page. Shown in the settings
+  description: string;
+  // relative or absolute URL or path to the plugin's page
+  url: string;
+  // relative or absolute URL or path to the plugin's icon image
+  icon: string;
+}
+
+// context menu entry being configured in the plugin configuration
+export interface MenuEntry {
+  // id of the plugin that the menu entry belongs to
+  plugin_id: string;
+  // identifier of the menu entry action. Used to know which entry to trigger when clicking on the context menu
+  action_key: string;
+  // text of the menu entry. Shown in the context menu
+  text: string;
+  // icon of the menu entry. Shown in the context menu
+  icon?: React.ReactNode;
+}
+
+// an action from the main panel that can be triggered and performs an action in the main panel
+export type MainPanelAction = {
+  plugin_id: string;
+  action_key: string;
+} & Record<string, string>;
+
+// an action from the context menu that can be triggered and performs an action in the sidebar plugin
+export interface ContextMenuAction {
+  // selected text when clicking on the context menu
+  text: string;
+  // id of the plugin that the action belongs to
+  plugin_id: string;
+  // key of the action. Used to know which action to trigger when clicking on the context menu
+  action_key: string
+}
+
+/**
+ * Rimori plugin structure representing the complete configuration
+ * of a Rimori plugin with all metadata and configuration options.
+ */
+export interface RimoriPluginConfig {
+  id: string;
+  /**
+   * Basic information about the plugin including branding and core details.
+   */
+  info: {
+    /** The display name of the plugin shown to users */
+    title: string;
+    /** Detailed description introducing the plugin */
+    description: string;
+    /** relative or absolute URL or path to the plugin's logo/icon image */
+    logo: string;
+    /** Optional website URL for the plugin's homepage or link to plugins owner for contributions */
+    website?: string;
+  }
+  /**
+   * Configuration for different types of pages.
+   */
+  pages: {
+    /** 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[];
+    /** Array of sidebar pages that appear in the sidebar for quick access (can be disabled using the 'show' flag) */
+    sidebar: SidebarPage[];
+    /** 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 */
+    topics?: string[];
+  }
+  /**
+   * Context menu actions that the plugin registers to appear in right-click menus throughout the application.
+   */
+  context_menu_actions: Omit<MenuEntry, "plugin_id">[];
+  /**
+   * Documentation paths for different types of plugin documentation.
+   */
+  documentation: {
+    /** Path to the general overview documentation. It's shown upon installation of the plugin. */
+    overview_path: string;
+    /** Path to user-facing documentation and guides */
+    user_path: string;
+    /** Path to developer documentation for plugin development */
+    developer_path: string;
+  }
+  /**
+   * Configuration for the plugin's web worker if it uses background processing or exposes actions to other plugins.
+   */
+  worker?: {
+    /** Relative path to the web worker JavaScript file. Mostly it's 'web-worker.js' which is located in the public folder. */
+    url: string;
+    /** Optional array of event topics the worker should listen to in addition to events having the pluginId in the topic. Can be a wildcard. Example: 'global.topic.*' or 'pluginId.*' */
+    topics?: string[];
+  };
+}
+
+// copied from llm edge function
+
+export interface Tool {
+  name: string;
+  description: string;
+  parameters: {
+    name: string;
+    description: string;
+    type: "string" | "number" | "boolean";
+  }[];
+  execute?: (args: Record<string, any>) => Promise<unknown> | unknown | void;
+}
+
+/**
+ * The tool definition structure is used for LLM function calling and plugin action parameters.
+ * It defines the schema for tools that can be used by Language Learning Models (LLMs)
+ * and plugin actions.
+ * 
+ * @example
+ * ```typescript
+ * const flashcardTool: Tool = {
+ *   total_amount: {
+ *     type: 'string',
+ *     enum: ['default', '10', '20', '50'],
+ *     description: 'Number of flashcards to practice'
+ *   },
+ *   deck: {
+ *     type: 'string', 
+ *     enum: ['latest', 'random', 'oldest', 'mix', 'best_known'],
+ *     description: 'Type of deck to practice'
+ *   }
+ * };
+ * ```
+ * 
+ */
+export type ObjectTool = {
+  [key: string]: ToolParameter;
+};
+
+/**
+ * Parameter definition for LLM tools and plugin actions.
+ * Defines the structure, validation rules, and metadata for individual tool parameters.
+ * Used to create type-safe interfaces between LLMs, plugins, and the Rimori platform.
+ */
+interface ToolParameter {
+  /** The data type of the parameter - can be primitive, nested object, or array */
+  type: ToolParameterType;
+  /** Human-readable description of the parameter's purpose and usage */
+  description: string;
+  /** Optional array of allowed values for enumerated parameters */
+  enum?: string[];
+  /** Whether the parameter is optional */
+  optional?: boolean;
+}
+
+/**
+ * Union type defining all possible parameter types for LLM tools.
+ * Supports primitive types, nested objects for complex data structures,
+ * and arrays of objects for collections. The tuple notation [{}] indicates
+ * arrays of objects with a specific structure.
+ * 
+ * @example Primitive: 'string' | 'number' | 'boolean'
+ * @example Nested object: { name: { type: 'string' }, age: { type: 'number' } }
+ * @example Array of objects: [{ id: { type: 'string' }, value: { type: 'number' } }]
+ */
+type ToolParameterType =
+  | PrimitiveType
+  | { [key: string]: ToolParameter }  // for nested objects
+  | [{ [key: string]: ToolParameter }];  // for arrays of objects (notice the tuple type)
+
+/**
+ * Primitive data types supported by the LLM tool system.
+ * These align with JSON schema primitive types and TypeScript basic types.
+ */
+type PrimitiveType = 'string' | 'number' | 'boolean';

package/src/hooks/UseChatHook.ts

@@ -1,14 +1,15 @@
 import React from "react";
-import { Message, Tool, ToolInvocation } from "../controller/AIController";
+import { Tool } from "../fromRimori/PluginTypes";
 import { usePlugin } 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 { llm } = usePlugin();
+  const { ai } = usePlugin();
 
   const append = (appendMessages: Message[]) => {
-    llm.getSteamedText([...messages, ...appendMessages], (id, message, finished: boolean, toolInvocations?: ToolInvocation[]) => {
+    ai.getSteamedText([...messages, ...appendMessages], (id, message, finished: boolean, toolInvocations?: ToolInvocation[]) => {
       const lastMessage = messages[messages.length - 1];
       setIsLoading(!finished);
 
@@ -16,7 +17,7 @@ export function useChat(tools?: Tool[]) {
         lastMessage.content = message;
         setMessages([...messages, lastMessage]);
       } else {
-        setMessages([...messages, ...appendMessages, { id, role: 'assistant', content: message, toolInvocations }]);
+        setMessages([...messages, ...appendMessages, { id, role: 'assistant', content: message, toolCalls: toolInvocations }]);
       }
     }, tools);
   };

package/src/index.ts

@@ -1,9 +1,11 @@
 // Re-export everything
-export * from './core';
 export * from './components';
 export * from "./hooks/UseChatHook";
-export * from "./plugin/RimoriClient";
+export * from "./plugin/PluginController";
 export * from "./providers/PluginProvider";
+export * from "./cli/types/DatabaseTypes";
 export * from "./utils/difficultyConverter";
 export * from "./utils/PluginUtils";
-export * from "./plugin/PluginController";
+export * from "./utils/Language";
+export * from "./fromRimori/PluginTypes";
+export { FirstMessages } from "./components/ai/utils";

package/src/plugin/AccomplishmentHandler.ts

@@ -1,4 +1,4 @@
-import { EventBus, EventBusMessage } from "./fromRimori/EventBus";
+import { EventBus, EventBusMessage } from "../fromRimori/EventBus";
 
 export type AccomplishmentMessage = EventBusMessage<MicroAccomplishmentPayload>;
 

package/src/plugin/PluginController.ts

@@ -1,19 +1,24 @@
-import { AuthSessionMissingError, createClient, SupabaseClient } from '@supabase/supabase-js';
-import { EventBus, EventBusMessage } from './fromRimori/EventBus';
+import { createClient, SupabaseClient } from '@supabase/supabase-js';
+import { UserInfo } from '../core/controller/SettingsController';
+import { EventBus, EventBusMessage } from '../fromRimori/EventBus';
+import { Plugin } from '../fromRimori/PluginTypes';
 import { RimoriClient } from "./RimoriClient";
-import { setTheme } from './ThemeSetter';
 import { StandaloneClient } from './StandaloneClient';
+import { setTheme } from './ThemeSetter';
 
 // Add declaration for WorkerGlobalScope
 declare const WorkerGlobalScope: any;
 
-interface SupabaseInfo {
+export interface RimoriInfo {
   url: string,
   key: string,
+  backendUrl: string,
   token: string,
   expiration: Date,
   tablePrefix: string,
   pluginId: string
+  installedPlugins: Plugin[]
+  profile: UserInfo
 }
 
 export class PluginController {
@@ -21,7 +26,7 @@ export class PluginController {
   private static instance: PluginController;
   private communicationSecret: string | null = null;
   private supabase: SupabaseClient | null = null;
-  private supabaseInfo: SupabaseInfo | null = null;
+  private rimoriInfo: RimoriInfo | null = null;
   private pluginId: string;
 
   private constructor(pluginId: string, standalone: boolean) {
@@ -34,7 +39,7 @@ export class PluginController {
 
     //no need to forward messages to parent in standalone mode
     if (standalone) return;
-    
+
     window.addEventListener("message", (event) => {
       // console.log("client: message received", event);
       const { topic, sender, data, eventId } = event.data.event as EventBusMessage;
@@ -78,47 +83,54 @@ export class PluginController {
     return this.communicationSecret;
   }
 
-  public async getClient(): Promise<{ supabase: SupabaseClient, tablePrefix: string, pluginId: string }> {
+  public async getClient(): Promise<{ supabase: SupabaseClient, info: RimoriInfo }> {
     if (
       this.supabase &&
-      this.supabaseInfo &&
-      this.supabaseInfo.expiration > new Date()
+      this.rimoriInfo &&
+      this.rimoriInfo.expiration > new Date()
     ) {
-      return { supabase: this.supabase, tablePrefix: this.supabaseInfo.tablePrefix, pluginId: this.supabaseInfo.pluginId };
+      return { supabase: this.supabase, info: this.rimoriInfo };
     }
 
-    const { data } = await EventBus.request<SupabaseInfo>(this.pluginId, "global.supabase.requestAccess");
-    this.supabaseInfo = data;
-    this.supabase = createClient(this.supabaseInfo.url, this.supabaseInfo.key, {
+    const { data } = await EventBus.request<RimoriInfo>(this.pluginId, "global.supabase.requestAccess");
+    this.rimoriInfo = data;
+    this.supabase = createClient(this.rimoriInfo.url, this.rimoriInfo.key, {
       accessToken: () => Promise.resolve(this.getToken())
     });
 
-    return { supabase: this.supabase, tablePrefix: this.supabaseInfo.tablePrefix, pluginId: this.supabaseInfo.pluginId };
+    return { supabase: this.supabase, info: this.rimoriInfo };
   }
 
   public async getToken() {
-    if (this.supabaseInfo && this.supabaseInfo.expiration && this.supabaseInfo.expiration > new Date()) {
-      return this.supabaseInfo.token;
+    if (this.rimoriInfo && this.rimoriInfo.expiration && this.rimoriInfo.expiration > new Date()) {
+      return this.rimoriInfo.token;
     }
 
     const { data } = await EventBus.request<{ token: string, expiration: Date }>(this.pluginId, "global.supabase.requestAccess");
 
-    if (!this.supabaseInfo) {
+    if (!this.rimoriInfo) {
       throw new Error("Supabase info not found");
     }
 
-    this.supabaseInfo.token = data.token;
-    this.supabaseInfo.expiration = data.expiration;
+    this.rimoriInfo.token = data.token;
+    this.rimoriInfo.expiration = data.expiration;
 
-    return this.supabaseInfo.token;
+    return this.rimoriInfo.token;
   }
 
   public getSupabaseUrl() {
-    if (!this.supabaseInfo) {
+    if (!this.rimoriInfo) {
       throw new Error("Supabase info not found");
     }
 
-    return this.supabaseInfo.url;
+    return this.rimoriInfo.url;
+  }
+
+  public getBackendUrl() {
+    if (!this.rimoriInfo) {
+      throw new Error("Rimori info not found");
+    }
+    return this.rimoriInfo.backendUrl;
   }
 
   public getGlobalEventTopic(preliminaryTopic: string) {
@@ -138,7 +150,7 @@ export class PluginController {
       throw new Error(`The event topic must consist of 3 parts. <pluginId>.<topic area>.<action>. Received: ${preliminaryTopic}`);
     }
 
-    const topicRoot = this.supabaseInfo?.pluginId ?? "global";
+    const topicRoot = this.rimoriInfo?.pluginId ?? "global";
     return `${topicRoot}.${preliminaryTopic}`;
   }
 

package/src/plugin/RimoriClient.ts

@@ -1,23 +1,16 @@
 import { PostgrestQueryBuilder } from "@supabase/postgrest-js";
 import { SupabaseClient } from "@supabase/supabase-js";
 import { GenericSchema } from "@supabase/supabase-js/dist/module/lib/types";
-import { generateText, Message, OnLLMResponse, streamChatGPT, Tool } from "../controller/AIController";
-import { generateObject as generateObjectFunction, ObjectRequest } from "../controller/ObjectController";
-import { SettingsController, UserInfo } from "../controller/SettingsController";
-import { BasicAssignment, SharedContent, SharedContentController, SharedContentFilter, SharedContentObjectRequest } from "../controller/SharedContentController";
-import { getPlugins } from "../controller/SidePluginController";
-import { getSTTResponse, getTTSResponse } from "../controller/VoiceController";
+import { generateText, Message, OnLLMResponse, streamChatGPT } from "../core/controller/AIController";
+import { generateObject as generateObjectFunction, ObjectRequest } from "../core/controller/ObjectController";
+import { SettingsController, UserInfo } from "../core/controller/SettingsController";
+import { SharedContent, SharedContentController, SharedContentFilter, SharedContentObjectRequest } from "../core/controller/SharedContentController";
+import { getSTTResponse, getTTSResponse } from "../core/controller/VoiceController";
+import { EventBus, EventBusMessage, EventHandler, EventPayload } from "../fromRimori/EventBus";
+import { Plugin, Tool } from "../fromRimori/PluginTypes";
 import { AccomplishmentHandler, AccomplishmentPayload } from "./AccomplishmentHandler";
-import { EventBus, EventBusMessage, EventHandler, EventPayload } from "./fromRimori/EventBus";
-import { Plugin } from "./fromRimori/PluginTypes";
-import { PluginController } from "./PluginController";
+import { PluginController, RimoriInfo } from "./PluginController";
 
-interface RimoriClientOptions {
-  pluginController: PluginController;
-  supabase: SupabaseClient;
-  tablePrefix: string;
-  pluginId: string;
-}
 
 interface Db {
   from: {
@@ -66,16 +59,20 @@ export class RimoriClient {
   private sharedContentController: SharedContentController;
   private accomplishmentHandler: AccomplishmentHandler;
   private supabaseUrl: string;
-  public db: Db;
+  private installedPlugins: Plugin[];
+  private profile: UserInfo;
   public plugin: PluginInterface;
+  public db: Db;
 
-  private constructor(options: RimoriClientOptions) {
-    this.superbase = options.supabase;
-    this.pluginController = options.pluginController;
-    this.settingsController = new SettingsController(options.supabase, options.pluginId);
+  private constructor(supabase: SupabaseClient, info: RimoriInfo, pluginController: PluginController) {
+    this.superbase = supabase;
+    this.pluginController = pluginController;
+    this.settingsController = new SettingsController(supabase, info.pluginId);
     this.sharedContentController = new SharedContentController(this.superbase, this);
     this.supabaseUrl = this.pluginController.getSupabaseUrl();
-    this.accomplishmentHandler = new AccomplishmentHandler(options.pluginId);
+    this.accomplishmentHandler = new AccomplishmentHandler(info.pluginId);
+    this.installedPlugins = info.installedPlugins;
+    this.profile = info.profile;
 
     this.from = this.from.bind(this);
 
@@ -83,11 +80,11 @@ export class RimoriClient {
       from: this.from,
       storage: this.superbase.storage,
       // functions: this.superbase.functions,
-      tablePrefix: options.tablePrefix,
+      tablePrefix: info.tablePrefix,
       getTableName: this.getTableName.bind(this),
     }
     this.plugin = {
-      pluginId: options.pluginId,
+      pluginId: info.pluginId,
       setSettings: async (settings: any) => {
         await this.settingsController.setSettings(settings);
       },
@@ -95,10 +92,10 @@ export class RimoriClient {
         return await this.settingsController.getSettings<T>(defaultSettings);
       },
       getInstalled: async (): Promise<Plugin[]> => {
-        return getPlugins(this.superbase);
+        return this.installedPlugins;
       },
       getUserInfo: async (): Promise<UserInfo> => {
-        return this.settingsController.getUserInfo();
+        return this.profile;
       }
     }
   }
@@ -132,11 +129,11 @@ export class RimoriClient {
      * Subscribe to an event.
      * @param topic The topic to subscribe to.
      * @param callback The callback to call when the event is emitted.
-     * @returns The unsubscribe ids.
+     * @returns An EventListener object containing an off() method to unsubscribe the listeners.
      */
     on: <T = EventPayload>(topic: string | string[], callback: EventHandler<T>) => {
       const topics = Array.isArray(topic) ? topic : [topic];
-      return topics.map(topic => EventBus.on<T>(this.pluginController.getGlobalEventTopic(topic), callback));
+      return EventBus.on<T>(topics.map(t => this.pluginController.getGlobalEventTopic(t)), callback);
     },
     /**
      * Subscribe to an event once.
@@ -151,8 +148,9 @@ export class RimoriClient {
      * @param topic The topic to respond to.
      * @param data The data to respond with.
      */
-    respond: <T = EventPayload>(topic: string, data: EventPayload | ((data: EventBusMessage<T>) => EventPayload | Promise<EventPayload>)) => {
-      EventBus.respond(this.plugin.pluginId, this.pluginController.getGlobalEventTopic(topic), data);
+    respond: <T = EventPayload>(topic: string | string[], data: EventPayload | ((data: EventBusMessage<T>) => EventPayload | Promise<EventPayload>)) => {
+      const topics = Array.isArray(topic) ? topic : [topic];
+      EventBus.respond(this.plugin.pluginId, topics.map(t => this.pluginController.getGlobalEventTopic(t)), data);
     },
     /**
      * Emit an accomplishment.
@@ -176,14 +174,20 @@ export class RimoriClient {
      * @param text Optional text to be used for the action like for example text that the translator would look up.
      */
     emitSidebarAction: (pluginId: string, actionKey: string, text?: string) => {
-      this.event.emit("global.sidebar.triggerAction", { pluginId, actionKey, text });
+      this.event.emit("global.sidebar.triggerAction", { plugin_id: pluginId, action_key: actionKey, text });
+    }
+  }
+
+  public navigation = {
+    toDashboard: () => {
+      this.event.emit("global.navigation.triggerToDashboard");
     }
   }
 
   public static async getInstance(pluginController: PluginController): Promise<RimoriClient> {
     if (!RimoriClient.instance) {
-      const { supabase, tablePrefix, pluginId } = await pluginController.getClient();
-      RimoriClient.instance = new RimoriClient({ pluginController, supabase, tablePrefix, pluginId });
+      const client = await pluginController.getClient();
+      RimoriClient.instance = new RimoriClient(client.supabase, client.info, pluginController);
     }
     return RimoriClient.instance;
   }
@@ -201,17 +205,20 @@ export class RimoriClient {
   }
 
   private getTableName(type: string) {
+    if (type.startsWith("global_")) {
+      return type.replace("global_", "");
+    }
     return this.db.tablePrefix + "_" + type;
   }
 
-  public llm = {
+  public ai = {
     getText: async (messages: Message[], tools?: Tool[]): Promise<string> => {
       const token = await this.pluginController.getToken();
-      return generateText(this.supabaseUrl, messages, tools || [], token).then(({ messages }) => messages[0].content[0].text);
+      return generateText(this.pluginController.getBackendUrl(), messages, tools || [], token).then(({ messages }) => messages[0].content[0].text);
     },
     getSteamedText: async (messages: Message[], onMessage: OnLLMResponse, tools?: Tool[]) => {
       const token = await this.pluginController.getToken();
-      streamChatGPT(this.supabaseUrl, messages, tools || [], onMessage, token);
+      streamChatGPT(this.pluginController.getBackendUrl(), messages, tools || [], onMessage, token);
     },
     getVoice: async (text: string, voice = "alloy", speed = 1, language?: string): Promise<Blob> => {
       const token = await this.pluginController.getToken();
@@ -240,7 +247,7 @@ export class RimoriClient {
        * @param id The id of the shared content item.
        * @returns The shared content item.
        */
-      get: async <T = any>(contentType: string, id: string): Promise<BasicAssignment<T>> => {
+      get: async <T = any>(contentType: string, id: string): Promise<SharedContent<T>> => {
         return await this.sharedContentController.getSharedContent(contentType, id);
       },
       /**
@@ -250,7 +257,7 @@ export class RimoriClient {
        * @param limit The optional limit for the number of results.
        * @returns The list of shared content items.
        */
-      getList: async <T = any>(contentType: string, filter?: SharedContentFilter, limit?: number): Promise<BasicAssignment<T>[]> => {
+      getList: async <T = any>(contentType: string, filter?: SharedContentFilter, limit?: number): Promise<SharedContent<T>[]> => {
         return await this.sharedContentController.getSharedContentList(contentType, filter, limit);
       },
       /**
@@ -266,7 +273,7 @@ export class RimoriClient {
         generatorInstructions: SharedContentObjectRequest,
         filter?: SharedContentFilter,
         privateTopic?: boolean,
-      ): Promise<BasicAssignment<T>> => {
+      ): Promise<SharedContent<T>> => {
         return await this.sharedContentController.getNewSharedContent(contentType, generatorInstructions, filter, privateTopic);
       },
       /**
@@ -274,7 +281,7 @@ export class RimoriClient {
        * @param content The content to create.
        * @returns The new shared content item.
        */
-      create: async <T = any>(content: Omit<SharedContent<T>, 'id'>): Promise<BasicAssignment<T>> => {
+      create: async <T = any>(content: Omit<SharedContent<T>, 'id'>): Promise<SharedContent<T>> => {
         return await this.sharedContentController.createSharedContent(content);
       },
       /**
@@ -283,7 +290,7 @@ export class RimoriClient {
        * @param content The content to update.
        * @returns The updated shared content item.
        */
-      update: async <T = any>(id: string, content: Partial<SharedContent<T>>): Promise<BasicAssignment<T>> => {
+      update: async <T = any>(id: string, content: Partial<SharedContent<T>>): Promise<SharedContent<T>> => {
         return await this.sharedContentController.updateSharedContent(id, content);
       },
       /**
@@ -299,7 +306,7 @@ export class RimoriClient {
        * @param id The id of the shared content item to remove.
        * @returns The removed shared content item.
        */
-      remove: async (id: string): Promise<BasicAssignment<any>> => {
+      remove: async (id: string): Promise<SharedContent<any>> => {
         return await this.sharedContentController.removeSharedContent(id);
       }
     }

package/src/plugin/StandaloneClient.ts

@@ -1,5 +1,6 @@
-import { EventBus } from "./fromRimori/EventBus";
 import { createClient, SupabaseClient } from "@supabase/supabase-js";
+import { EventBus } from "../fromRimori/EventBus";
+import { DEFAULT_ANON_KEY, DEFAULT_ENDPOINT } from "../utils/endpoint";
 
 export interface StandaloneConfig {
   url: string,
@@ -18,14 +19,13 @@ export class StandaloneClient {
 
   public static async getInstance(): Promise<StandaloneClient> {
     if (!StandaloneClient.instance) {
-      const config = await fetch("http://localhost:3000/config.json").then(res => res.json()).catch(err => {
+      const config = await fetch("https://app.rimori.se/config.json").then(res => res.json()).catch(err => {
         console.warn("Error fetching config.json, using default values", err);
-        return {
-          SUPABASE_URL: "https://pheptqdoqsdnadgoihvr.supabase.co",
-          SUPABASE_ANON_KEY: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InBoZXB0cWRvcXNkbmFkZ29paHZyIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MzE2OTY2ODcsImV4cCI6MjA0NzI3MjY4N30.4GPFAXTF8685FaXISdAPNCIM-H3RGLo8GbyhQpu1mP0",
-        }
       });
-      StandaloneClient.instance = new StandaloneClient({ url: config.SUPABASE_URL, key: config.SUPABASE_ANON_KEY });
+      StandaloneClient.instance = new StandaloneClient({
+        url: config?.SUPABASE_URL || DEFAULT_ENDPOINT,
+        key: config?.SUPABASE_ANON_KEY || DEFAULT_ANON_KEY,
+      });
     }
     return StandaloneClient.instance;
   }
@@ -58,7 +58,10 @@ export class StandaloneClient {
     EventBus.respond("standalone", "global.supabase.requestAccess", async () => {
       const session = await supabase.auth.getSession();
       console.log("session", session);
-      const { data, error } = await supabase.functions.invoke("plugin-token", { headers: { authorization: `Bearer ${session.data.session?.access_token}` } });
+      const { data, error } = await supabase.functions.invoke("plugin-token", {
+        body: { pluginId },
+        headers: { authorization: `Bearer ${session.data.session?.access_token}` },
+      });
       if (error) {
         throw new Error("Failed to get plugin token. " + error.message);
       }

package/src/plugin/ThemeSetter.ts

@@ -1,16 +1,20 @@
 export function setTheme() {
-  const urlParams = new URLSearchParams(window.location.search);
-
-  let theme = urlParams.get('theme');
-  if (!theme || theme === 'system') {
-    theme = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
-  }
-
   document.documentElement.classList.add("dark:text-gray-200");
 
-  if (theme === 'dark') {
+  if (isDarkTheme()) {
     document.documentElement.setAttribute("data-theme", "dark");
     document.documentElement.classList.add('dark', "dark:bg-gray-950");
     document.documentElement.style.background = "hsl(var(--background))";
   }
+}
+
+export function isDarkTheme(): boolean {
+  const urlParams = new URLSearchParams(window.location.search);
+
+  let theme = urlParams.get('theme');
+  if (!theme || theme === 'system') {
+    return window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
+  }
+
+  return theme === 'dark';
 }