@rimori/client 1.0.3 → 1.0.5

package/src/plugin/RimoriClient.ts

@@ -1,5 +1,6 @@
 import { PluginController } from "./PluginController";
 import { SupabaseClient } from "@supabase/supabase-js";
+import { EventBusMessage, EventPayload } from "./fromRimori/EventBus";
 import { SettingsController } from "../controller/SettingsController";
 import { GenericSchema } from "@supabase/supabase-js/dist/module/lib/types";
 import { getSTTResponse, getTTSResponse } from "../controller/VoiceController";
@@ -8,6 +9,8 @@ import { SharedContentController, BasicAssignment } from "../controller/SharedCo
 import { streamChatGPT, Message, Tool, OnLLMResponse, generateText } from "../controller/AIController";
 import { generateObject as generateObjectFunction, ObjectRequest } from "../controller/ObjectController";
 import { getPlugins, Plugin } from "../controller/SidePluginController";
+import { UserInfo } from "../controller/SettingsController";
+import { EventBus, EventHandler } from "./fromRimori/EventBus";
 
 interface RimoriClientOptions {
     pluginController: PluginController;
@@ -16,38 +19,132 @@ interface RimoriClientOptions {
     pluginId: string;
 }
 
+interface Db {
+    from: {
+        <TableName extends string & keyof GenericSchema['Tables'], Table extends GenericSchema['Tables'][TableName]>(relation: TableName): PostgrestQueryBuilder<GenericSchema, Table, TableName>;
+        <ViewName extends string & keyof GenericSchema['Views'], View extends GenericSchema['Views'][ViewName]>(relation: ViewName): PostgrestQueryBuilder<GenericSchema, View, ViewName>;
+    };
+    rpc: <Fn extends GenericSchema['Functions'][string], FnName extends string & keyof GenericSchema['Functions']>(functionName: FnName, args?: Fn["Args"], options?: {
+        head?: boolean;
+        get?: boolean;
+        count?: "exact" | "planned" | "estimated";
+    }) => PostgrestFilterBuilder<GenericSchema, Fn["Returns"] extends any[] ? Fn["Returns"][number] extends Record<string, unknown> ? Fn["Returns"][number] : never : never, Fn["Returns"], string, null>;
+    functions: SupabaseClient["functions"];
+    storage: SupabaseClient["storage"];
+}
+
+interface PluginInterface {
+    pluginId: string;
+    tablePrefix: string;
+    setSettings: (settings: any) => Promise<void>;
+    /**
+     * 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.
+     * @param genericSettings The type of settings to get.
+     * @returns The settings for the plugin. 
+     */
+    getSettings: <T extends object>(defaultSettings: T) => Promise<T>;
+    /**
+    * Fetches all installed plugins.
+    * @returns A promise that resolves to an array of plugins
+    */
+    getInstalled: () => Promise<Plugin[]>;
+    getUserInfo: () => Promise<UserInfo>;
+}
+
 export class RimoriClient {
     private static instance: RimoriClient;
     private superbase: SupabaseClient;
-    private plugin: PluginController;
-    public functions: SupabaseClient["functions"];
-    public storage: SupabaseClient["storage"];
-    public pluginId: string;
-    public tablePrefix: string;
+    private pluginController: PluginController;
     private settingsController: SettingsController;
     private sharedContentController: SharedContentController;
+    private supabaseUrl: string;
+    public db: Db;
+    public plugin: PluginInterface;
 
     private constructor(options: RimoriClientOptions) {
         this.superbase = options.supabase;
-        this.pluginId = options.pluginId;
-        this.plugin = options.pluginController;
-        this.tablePrefix = options.tablePrefix;
-        this.storage = this.superbase.storage;
-        this.functions = this.superbase.functions;
+        this.pluginController = options.pluginController;
         this.settingsController = new SettingsController(options.supabase, options.pluginId);
         this.sharedContentController = new SharedContentController(this);
+        this.supabaseUrl = this.pluginController.getSupabaseUrl();
+
         this.rpc = this.rpc.bind(this);
         this.from = this.from.bind(this);
-        this.emit = this.emit.bind(this);
-        this.request = this.request.bind(this);
-        this.subscribe = this.subscribe.bind(this);
-        this.getSettings = this.getSettings.bind(this);
-        this.setSettings = this.setSettings.bind(this);
-        this.getAIResponse = this.getAIResponse.bind(this);
-        this.generateObject = this.generateObject.bind(this);
-        this.getVoiceResponse = this.getVoiceResponse.bind(this);
-        this.getAIResponseStream = this.getAIResponseStream.bind(this);
-        this.getVoiceToTextResponse = this.getVoiceToTextResponse.bind(this);
+
+        this.db = {
+            rpc: this.rpc,
+            from: this.from,
+            storage: this.superbase.storage,
+            functions: this.superbase.functions,
+        }
+        this.plugin = {
+            pluginId: options.pluginId,
+            tablePrefix: options.tablePrefix,
+            setSettings: async (settings: any) => {
+                await this.settingsController.setSettings(settings);
+            },
+            getSettings: async <T extends object>(defaultSettings: T): Promise<T> => {
+                return await this.settingsController.getSettings<T>(defaultSettings);
+            },
+            getInstalled: async (): Promise<Plugin[]> => {
+                return getPlugins(this.superbase);
+            },
+            getUserInfo: async (): Promise<UserInfo> => {
+                return this.settingsController.getUserInfo();
+            }
+        }
+    }
+
+    public event = {
+        /**
+         * 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) => {
+            const globalTopic = this.pluginController.getGlobalEventTopic(topic);
+            EventBus.emit(this.plugin.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.pluginController.getGlobalEventTopic(topic);
+            return EventBus.request<T>(this.plugin.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.
+         */
+        on: <T = EventPayload>(topic: string, callback: EventHandler<T>) => {
+            EventBus.on<T>(this.pluginController.getGlobalEventTopic(topic), 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>) => {
+            EventBus.once<T>(this.pluginController.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, data: EventPayload | ((data: EventBusMessage<T>) => EventPayload | Promise<EventPayload>)) => {
+            EventBus.respond(this.plugin.pluginId, this.pluginController.getGlobalEventTopic(topic), data);
+        }
     }
 
     public static async getInstance(pluginController: PluginController): Promise<RimoriClient> {
@@ -58,15 +155,15 @@ export class RimoriClient {
         return RimoriClient.instance;
     }
 
-    public from<
+    private from<
         TableName extends string & keyof GenericSchema['Tables'],
         Table extends GenericSchema['Tables'][TableName]
     >(relation: TableName): PostgrestQueryBuilder<GenericSchema, Table, TableName>
-    public from<
+    private from<
         ViewName extends string & keyof GenericSchema['Views'],
         View extends GenericSchema['Views'][ViewName]
     >(relation: ViewName): PostgrestQueryBuilder<GenericSchema, View, ViewName>
-    public from(relation: string): PostgrestQueryBuilder<GenericSchema, any, any> {
+    private from(relation: string): PostgrestQueryBuilder<GenericSchema, any, any> {
         return this.superbase.from(this.getTableName(relation));
     }
 
@@ -93,7 +190,7 @@ export class RimoriClient {
     * `"estimated"`: Uses exact count for low numbers and planned count for high
     * numbers.
     */
-    rpc<Fn extends GenericSchema['Functions'][string], FnName extends string & keyof GenericSchema['Functions']>(
+    private rpc<Fn extends GenericSchema['Functions'][string], FnName extends string & keyof GenericSchema['Functions']>(
         functionName: FnName,
         args: Fn['Args'] = {},
         options: {
@@ -116,68 +213,33 @@ export class RimoriClient {
     }
 
     private getTableName(type: string) {
-        return this.tablePrefix + "_" + type;
-    }
-
-    public subscribe(eventName: string, callback: (_id: number, data: any) => void) {
-        this.plugin.subscribe(eventName, callback);
-    }
-
-    public request<T>(eventName: string, data?: any): Promise<T> {
-        return this.plugin.request(eventName, data);
-    }
-
-    public emit(eventName: string, data: any) {
-        this.plugin.emit(eventName, data);
-    }
-
-    /**
-    * 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.
-    * @param genericSettings The type of settings to get.
-    * @returns The settings for the plugin. 
-    */
-    public async getSettings<T extends object>(defaultSettings: T, genericSettings?: "user" | "system"): Promise<T> {
-        return this.settingsController.getSettings<T>(defaultSettings, genericSettings);
-    }
-
-    public async setSettings(settings: any, genericSettings?: "user" | "system") {
-        await this.settingsController.setSettings(settings, genericSettings);
-    }
-
-    public async getAIResponse(messages: Message[], tools?: Tool[]): Promise<string> {
-        const token = await this.plugin.getToken();
-        return generateText(messages, tools || [], token).then(response => response.messages[0].content[0].text);
-    }
-
-    public async getAIResponseStream(messages: Message[], onMessage: OnLLMResponse, tools?: Tool[]) {
-        const token = await this.plugin.getToken();
-        streamChatGPT(messages, tools || [], onMessage, token);
-    }
-
-    public async getVoiceResponse(text: string, voice = "alloy", speed = 1, language?: string): Promise<Blob> {
-        return getTTSResponse(
-            this.plugin.getSupabaseUrl(),
-            { input: text, voice, speed, language },
-            await this.plugin.getToken()
-        );
-    }
-
-    public getVoiceToTextResponse(file: Blob): Promise<string> {
-        return getSTTResponse(this.superbase, file);
-    }
-
-    /**
-     * Fetches all installed plugins.
-     * @returns A promise that resolves to an array of plugins
-     */
-    public async getPlugins(): Promise<Plugin[]> {
-        return getPlugins(this.superbase);
+        return this.plugin.tablePrefix + "_" + type;
     }
 
-    public async generateObject(request: ObjectRequest): Promise<any> {
-        const token = await this.plugin.getToken();
-        return generateObjectFunction(request, token);
+    public llm = {
+        getText: async (messages: Message[], tools?: Tool[]): Promise<string> => {
+            const token = await this.pluginController.getToken();
+            return generateText(this.supabaseUrl, messages, tools || [], token).then(response => response.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);
+        },
+        getVoice: async (text: string, voice = "alloy", speed = 1, language?: string): Promise<Blob> => {
+            return getTTSResponse(
+                this.pluginController.getSupabaseUrl(),
+                { input: text, voice, speed, language },
+                await this.pluginController.getToken()
+            );
+        },
+        getTextFromVoice: (file: Blob): Promise<string> => {
+            return getSTTResponse(this.superbase, file);
+        },
+        getObject: async (request: ObjectRequest): Promise<any> => {
+            const token = await this.pluginController.getToken();
+            return generateObjectFunction(this.pluginController.getSupabaseUrl(), request, token);
+        },
+        // getSteamedObject: this.generateObjectStream,
     }
 
     /**
@@ -215,6 +277,6 @@ export class RimoriClient {
     }
 
     public triggerSidebarAction(pluginId: string, actionKey: string, text?: string) {
-        this.emit("triggerSidebarAction", { pluginId, actionKey, text });
+        this.event.emit("global.sidebar.triggerAction", { pluginId, actionKey, text });
     }
 }

package/src/plugin/ThemeSetter.ts

@@ -2,8 +2,6 @@ export function setTheme() {
   const urlParams = new URLSearchParams(window.location.search);
 
   let theme = urlParams.get('theme');
-  const isSidebar = urlParams.get('applicationMode') === "sidebar";
-
   if (!theme || theme === 'system') {
     theme = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
   }
@@ -11,7 +9,8 @@ export function setTheme() {
   document.documentElement.classList.add("dark:text-gray-200", "bg-white");
 
   if (theme === 'dark') {
-    document.documentElement.classList.add('dark', isSidebar ? "bg-gray-920" : "bg-gray-950");
-    document.documentElement.style.background = isSidebar ? "rgb(6, 12, 30)" : "rgb(3, 7, 18)";
+    document.documentElement.setAttribute("data-theme", "dark");
+    document.documentElement.classList.add('dark', "bg-gray-950");
+    document.documentElement.style.background = "hsl(var(--background))";
   }
 }

package/src/plugin/fromRimori/EventBus.ts

@@ -0,0 +1,301 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type EventPayload = Record<string, any>;
+
+/**
+ * Interface representing a message sent through the EventBus
+ * 
+ * Debug capabilities:
+ * - System-wide debugging: Send an event to "global.system.requestDebug" 
+ *   Example: `EventBus.emit("yourPluginId", "global.system.requestDebug");`
+ */
+export interface EventBusMessage<T = EventPayload> {
+  //timestamp of the event
+  timestamp: string;
+  //unique ID of the event
+  eventId: number;
+  //plugin id or "global" for global events
+  sender: string;
+  //the topic of the event consisting of the plugin id, key area and action e.g. "translator.word.triggerTranslation"
+  topic: string;
+  //any type of data to be transmitted
+  data: T;
+  //indicated if the debug mode is active
+  debug: boolean;
+}
+
+export type EventHandler<T = EventPayload> = (event: EventBusMessage<T>) => void | Promise<void>;
+
+interface Listeners<T = EventPayload> {
+  id: number;
+  handler: EventHandler<T>;
+  ignoreSender?: string[];
+}
+
+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 = false;
+  private evName: string = "";
+
+  private constructor() {
+    //private constructor
+  }
+
+  static getInstance(name?: string) {
+    if (!EventBusHandler.instance) {
+      EventBusHandler.instance = new EventBusHandler();
+
+      EventBusHandler.instance.on("global.system.requestDebug", () => {
+        EventBusHandler.instance!.debugEnabled = true;
+        console.log(`[${EventBusHandler.instance!.evName}] Debug mode enabled. Make sure debugging messages are enabled in the browser console.`);
+      });
+    }
+    if (name && EventBusHandler.instance.evName === "") {
+      EventBusHandler.instance.evName = name;
+    }
+    return EventBusHandler.instance;
+  }
+
+  private createEvent(sender: string, topic: string, data: EventPayload, eventId?: number): EventBusMessage {
+    const generatedEventId = eventId || Math.floor(Math.random() * 10000000000);
+
+    return {
+      eventId: generatedEventId,
+      timestamp: new Date().toISOString(),
+      sender,
+      topic,
+      data,
+      debug: this.debugEnabled,
+    };
+  }
+
+  /**
+   * Emits an event to the event bus. Can be a new event or a response to a request.
+   * @param sender - The sender of the event.
+   * @param topic - The topic of the event.
+   * @param data - The data of the event.
+   * @param eventId - The event id of the event.
+   * 
+   * The topic format is: **pluginId.area.action**
+   * 
+   * Example topics:
+   * - pl1234.card.requestHard
+   * - pl1234.card.requestNew
+   * - pl1234.card.requestAll
+   * - pl1234.card.create
+   * - pl1234.card.update
+   * - pl1234.card.delete
+   * - pl1234.card.triggerBackup
+   */
+  public emit<T = EventPayload>(sender: string, topic: string, data?: T, eventId?: number): void {
+    this.emitInternal(sender, topic, data || {}, eventId);
+  }
+
+  private emitInternal(sender: string, topic: string, data: EventPayload, eventId?: number, skipResponseTrigger = false): void {
+    if (!this.validateTopic(topic)) {
+      this.logAndThrowError(false, `Invalid topic: ` + topic);
+      return;
+    }
+
+    const event = this.createEvent(sender, topic, data, eventId);
+
+    const handlers = this.getMatchingHandlers(event.topic);
+    handlers.forEach(handler => {
+      if (handler.ignoreSender && handler.ignoreSender.includes(sender)) {
+        // console.log("ignore event as its in the ignoreSender list", { event, ignoreList: handler.ignoreSender });
+        return;
+      }
+      handler.handler(event);
+    });
+    this.logIfDebug(`Emitting event to ` + topic, event);
+    if (handlers.size === 0) {
+      this.logAndThrowError(false, `No handlers found for topic: ` + topic);
+    }
+
+    // If it's a response to a request
+    if (eventId && this.responseResolvers.has(eventId) && !skipResponseTrigger) {
+      // console.log("[Rimori] Resolving response to request: " + eventId, event.data);
+      this.responseResolvers.get(eventId)!(event);
+      this.responseResolvers.delete(eventId);
+    }
+  }
+
+  /**
+   * Subscribes to an event on the event bus.
+   * @param topics - The topic of the event.
+   * @param handler - The handler to be called when the event is emitted.
+   * @param ignoreSender - The senders to ignore.
+   * @returns The ids of the listeners.
+   */
+  public on<T = EventPayload>(topics: string | string[], handler: EventHandler<T>, ignoreSender: string[] = []): string[] {
+    return this.toArray(topics).map(topic => {
+      if (!this.validateTopic(topic)) {
+        this.logAndThrowError(true, `Invalid topic: ` + topic);
+      }
+
+      if (!this.listeners.has(topic)) {
+        this.listeners.set(topic, new Set());
+      }
+      const id = Math.floor(Math.random() * 10000000000);
+
+      // Type assertion to handle the generic type mismatch
+      const eventHandler = handler as unknown as EventHandler<EventPayload>;
+      this.listeners.get(topic)!.add({ id, handler: eventHandler, ignoreSender });
+
+      this.logIfDebug(`Subscribed to ` + topic, { listenerId: id, ignoreSender });
+
+      return btoa(JSON.stringify({ topic, id }));
+    });
+  }
+
+  /**
+   * Subscribes to an event, processes the data and emits a response on the event bus.
+   * @param sender - The sender of the event.
+   * @param topic - The topic of the event.
+   * @param handler - The handler to be called when the event is received. The handler returns the data to be emitted. Can be a static object or a function.
+   * @returns The ids of the listeners.
+   */
+  public respond(sender: string, topic: string, handler: EventPayload | ((data: EventBusMessage) => EventPayload | Promise<EventPayload>)): string[] {
+    const ids = this.on(topic, async (data: EventBusMessage) => {
+      const response = typeof handler === "function" ? await handler(data) : handler;
+      this.emit(sender, topic, response, data.eventId);
+    }, [sender]);
+
+    this.logIfDebug(`Added respond listener ` + sender + " to topic " + topic, { listenerIds: ids, sender });
+    return ids;
+  }
+
+  /**
+   * Subscribes to an event on the event bus. The handler will be called once and then removed.
+   * @param topic - The topic of the event.
+   * @param handler - The handler to be called when the event is emitted.
+   */
+  public once<T = EventPayload>(topic: string, handler: EventHandler<T>): void {
+    if (!this.validateTopic(topic)) {
+      this.logAndThrowError(false, `Invalid topic: ` + topic);
+      return;
+    }
+
+    let ids: string[] = [];
+    const wrapper = (event: EventBusMessage<T>) => {
+      handler(event);
+      this.off(ids);
+    };
+    ids = this.on(topic, wrapper);
+
+    this.logIfDebug(`Added once listener ` + topic, { listenerIds: ids, topic });
+  }
+
+  /**
+   * Unsubscribes from an event on the event bus.
+   * @param listenerIds - The ids of the listeners to unsubscribe from.
+   */
+  public off(listenerIds: string | string[]): void {
+    this.toArray(listenerIds).forEach(fullId => {
+      const { topic, id } = JSON.parse(atob(fullId));
+
+      const listeners = this.listeners.get(topic) || new Set();
+
+      listeners.forEach(listener => {
+        if (listener.id === Number(id)) {
+          listeners.delete(listener);
+          this.logIfDebug(`Removed listener ` + fullId, { topic, listenerId: id });
+        }
+      });
+    });
+  }
+
+  private toArray(item: string | string[]): string[] {
+    return Array.isArray(item) ? item : [item];
+  }
+
+  /**
+   * Requests data from the event bus.
+   * @param sender - The sender of the event.
+   * @param topic - The topic of the event.
+   * @param data - The data of the event.
+   * @returns A promise that resolves to the event.
+   */
+  public async request<T = EventPayload>(sender: string, topic: string, data?: EventPayload): Promise<EventBusMessage<T>> {
+    if (!this.validateTopic(topic)) {
+      this.logAndThrowError(true, `Invalid topic: ` + topic);
+    }
+
+    const event = this.createEvent(sender, topic, data || {});
+
+    this.logIfDebug(`Requesting data from ` + topic, { event });
+
+    return new Promise<EventBusMessage<T>>(resolve => {
+      this.responseResolvers.set(event.eventId, (value: EventBusMessage<unknown>) => resolve(value as EventBusMessage<T>));
+      this.emitInternal(sender, topic, data || {}, event.eventId, true);
+    });
+  }
+
+  /**
+   * Gets the matching handlers for an event.
+   * @param topic - The topic of the event.
+   * @returns A set of handlers that match the event type.
+   */
+  private getMatchingHandlers(topic: string): Set<Listeners<EventPayload>> {
+    const exact = this.listeners.get(topic) || new Set();
+
+    // Find wildcard matches
+    const wildcard = [...this.listeners.entries()]
+      .filter(([key]) => key.endsWith("*") && topic.startsWith(key.slice(0, -1)))
+      .flatMap(([_, handlers]) => [...handlers]);
+    return new Set([...exact, ...wildcard]);
+  }
+
+  /**
+   * Validates the topic of an event.
+   * @param topic - The topic of the event.
+   * @returns True if the topic is valid, false otherwise.
+   */
+  private validateTopic(topic: string): boolean {
+    // Split event type into parts
+    const parts = topic.split(".");
+    const [plugin, area, action] = parts;
+
+    if (parts.length !== 3) {
+      if (parts.length === 1 && plugin === "*") {
+        return true;
+      }
+      if (parts.length === 2 && plugin !== "*" && area === "*") {
+        return true;
+      }
+      this.logAndThrowError(false, `Event type must have 3 parts separated by dots. Received: ` + topic);
+      return false;
+    }
+
+    if (action === "*") {
+      return true;
+    }
+
+    // Validate action part
+    const validActions = ["request", "create", "update", "delete", "trigger"];
+
+    if (validActions.some(a => action.startsWith(a))) {
+      return true;
+    }
+
+    this.logAndThrowError(false, `Invalid event topic name. The action: ` + action + ". Must be or start with one of: " + validActions.join(", "));
+    return false;
+  }
+
+  private logIfDebug(...args: (string | EventPayload)[]) {
+    if (this.debugEnabled) {
+      console.debug(`[${this.evName}] ` + args[0], ...args.slice(1));
+    }
+  }
+
+  private logAndThrowError(throwError: boolean, ...args: (string | EventPayload)[]) {
+    const message = `[${this.evName}] ` + args[0];
+    console.error(message, ...args.slice(1));
+    if (throwError) {
+      throw new Error(message);
+    }
+  }
+}
+
+export const EventBus = EventBusHandler.getInstance();

package/src/plugin/fromRimori/readme.md

@@ -0,0 +1,2 @@
+Files inside this folder are copied from Rimori and should not be changed. 
+If change is needed adapt it in Rimori and copy the file then over.