@rimori/client 2.1.8 → 2.2.0-next.1

package/.github/workflows/pre-release.yml

@@ -0,0 +1,105 @@
+name: Pre-Release Rimori Client
+
+on:
+  push:
+    branches: [dev]
+    paths:
+      - '**'
+      - '!.github/workflows/**'
+
+jobs:
+  pre-release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+          cache: 'yarn'
+          cache-dependency-path: yarn.lock
+
+      - name: Update npm
+        run: npm install -g npm@latest
+
+      - name: Install dependencies
+        run: yarn install --frozen-lockfile
+
+      - name: Build rimori-client (TypeScript verification)
+        run: yarn build
+
+      - name: Calculate next pre-release version
+        id: version
+        run: |
+          # Read current version from package.json (may be base or pre-release)
+          CURRENT_VERSION=$(node -p "require('./package.json').version")
+
+          # Extract base version (strip any pre-release suffix)
+          # Examples: "2.2.0" -> "2.2.0", "2.2.0-next.5" -> "2.2.0"
+          if [[ "$CURRENT_VERSION" =~ ^([0-9]+\.[0-9]+\.[0-9]+) ]]; then
+            BASE_VERSION="${BASH_REMATCH[1]}"
+          else
+            BASE_VERSION="$CURRENT_VERSION"
+          fi
+
+          # Try to get latest next version from npm
+          LATEST_NEXT=$(npm view @rimori/client@next version 2>/dev/null || echo "none")
+
+          if [ "$LATEST_NEXT" != "none" ]; then
+            # Extract base version and pre-release number from latest next version
+            # Example: "2.2.0-next.5" -> extract "2.2.0" and "5"
+            if [[ "$LATEST_NEXT" =~ ^([0-9]+\.[0-9]+\.[0-9]+)-next\.([0-9]+)$ ]]; then
+              LATEST_BASE="${BASH_REMATCH[1]}"
+              PRERELEASE_NUM="${BASH_REMATCH[2]}"
+              
+              # If base version changed, reset to 1, otherwise increment
+              if [ "$LATEST_BASE" != "$BASE_VERSION" ]; then
+                NEW_NUM=1
+              else
+                NEW_NUM=$((PRERELEASE_NUM + 1))
+              fi
+            else
+              # Fallback: if format doesn't match, start at 1
+              NEW_NUM=1
+            fi
+          else
+            # First pre-release
+            NEW_NUM=1
+          fi
+
+          NEW_VERSION="${BASE_VERSION}-next.${NEW_NUM}"
+          echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
+          echo "Base version: $BASE_VERSION"
+          echo "Calculated next version: $NEW_VERSION"
+
+      - name: Update package.json version
+        run: |
+          # Use node to update version directly (yarn version creates git tags)
+          node -e "const fs = require('fs'); const pkg = JSON.parse(fs.readFileSync('package.json')); pkg.version = '${{ steps.version.outputs.new_version }}'; fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2) + '\n');"
+
+      - name: Publish to npm
+        run: npm publish --tag next --access public
+        # Uses OIDC token automatically (no NODE_AUTH_TOKEN needed)
+        # Requires npm 11.5.1+ and id-token: write permission (already set)
+
+      - name: Commit version bump
+        run: |
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+          git add package.json
+          git commit -m "chore: bump @rimori/client to ${{ steps.version.outputs.new_version }} [skip ci]"
+          git push
+
+      - name: Output published version
+        run: |
+          echo "✅ Published @rimori/client@${{ steps.version.outputs.new_version }} to npm with @next tag"

package/dist/cli/types/DatabaseTypes.d.ts

@@ -42,8 +42,10 @@ export interface DbColumnDefinition {
     restrict?: {
         /** Restrictions for the user */
         user: Partial<Omit<DbPermissionDefinition, 'delete'>>;
-        /** Restrictions for the moderator */
-        moderator?: Partial<Omit<DbPermissionDefinition, 'delete'>>;
+        /** Restrictions for the guild moderator */
+        guild_moderator?: Partial<Omit<DbPermissionDefinition, 'delete'>>;
+        /** Restrictions for the language moderator */
+        lang_moderator?: Partial<Omit<DbPermissionDefinition, 'delete'>>;
     };
 }
 /**
@@ -69,8 +71,12 @@ export interface DbTableDefinition {
     description: string;
     /** Permissions for the table */
     permissions: {
+        /** Permissions for the user */
         user: DbPermissionDefinition;
-        moderator?: DbPermissionDefinition;
+        /** Permissions for the guild moderator */
+        guild_moderator?: DbPermissionDefinition;
+        /** Permissions for the language moderator */
+        lang_moderator?: DbPermissionDefinition;
     };
     /** Column definitions for the table */
     columns: {
@@ -81,11 +87,13 @@ export interface DbTableDefinition {
  * Permission definition for a database table.
  * NONE means the action is not allowed.
  * OWN means only do the action on your own records.
+ * GUILD means do the action on all records in the guild.
+ * LANG means do the action on all records in the language.
  * ALL means do the action on all records.
  *
  * Defines the permissions for a database table.
  */
-export type DbPermission = 'NONE' | 'OWN' | 'ALL';
+export type DbPermission = 'NONE' | 'OWN' | 'GUILD' | 'LANG' | 'ALL';
 /**
  * Permission definition for a database table.
  * Defines the permissions for a database table.

package/dist/controller/AccomplishmentController.js

@@ -6,7 +6,9 @@ export class AccomplishmentController {
     }
     emitAccomplishment(payload) {
         const accomplishmentPayload = Object.assign(Object.assign({}, payload), { type: 'durationMinutes' in payload ? 'macro' : 'micro' });
-        this.validateAccomplishment(accomplishmentPayload);
+        if (!this.validateAccomplishment(accomplishmentPayload)) {
+            return;
+        }
         const sanitizedPayload = this.sanitizeAccomplishment(accomplishmentPayload);
         const topic = 'global.accomplishment.trigger' + (accomplishmentPayload.type === 'macro' ? 'Macro' : 'Micro');
         EventBus.emit(this.pluginId, topic, sanitizedPayload);
@@ -29,7 +31,8 @@ export class AccomplishmentController {
         }
         //durationMinutes is required
         if (payload.type === 'macro' && payload.durationMinutes < 4) {
-            throw new Error('The duration must be at least 4 minutes');
+            console.warn('The duration must be at least 4 minutes');
+            return false;
         }
         //errorRatio is required
         if (payload.type === 'macro' && (payload.errorRatio < 0 || payload.errorRatio > 1)) {
@@ -43,6 +46,7 @@ export class AccomplishmentController {
                 }
             });
         }
+        return true;
     }
     sanitizeAccomplishment(payload) {
         var _a;

package/dist/controller/SettingsController.d.ts

@@ -16,6 +16,7 @@ export interface Language {
     capitalized: string;
     uppercase: string;
 }
+export type UserRole = 'user' | 'plugin_moderator' | 'lang_moderator' | 'admin';
 export interface UserInfo {
     skill_level_reading: LanguageLevel;
     skill_level_writing: LanguageLevel;
@@ -29,8 +30,7 @@ export interface UserInfo {
     story_genre: string;
     study_duration: number;
     /**
-     * The 2 letter language code of the language the user speaks natively.
-     * With the function getLanguageName, the language name can be retrieved.
+     * The language the user speaks natively.
      */
     mother_tongue: Language;
     /**
@@ -49,6 +49,10 @@ export interface UserInfo {
      * Optional: nearest big city (>100,000) near user's location
      */
     target_city?: string;
+    /**
+     * The user's role: 'user', 'plugin_moderator', 'lang_moderator', or 'admin'
+     */
+    user_role: UserRole;
 }
 export declare class SettingsController {
     private pluginId;

package/dist/controller/SharedContentController.js

@@ -28,31 +28,34 @@ export class SharedContentController {
     //this filter is there if the content should be filtered additionally by a column and value
     filter, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            let query = this.supabase
-                .from('shared_content')
-                .select('*, scc:shared_content_completed(id, state)')
-                .eq('content_type', contentType)
-                .not('scc.state', 'in', '("completed","ongoing","hidden")')
-                .is('deleted_at', null);
-            if ((options === null || options === void 0 ? void 0 : 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 } = yield query.limit(30);
-            if (error) {
-                console.error('error fetching new assignments:', error);
-                throw new Error('error fetching new assignments');
-            }
-            // console.log('newAssignments:', newAssignments);
-            if (!(options === null || options === void 0 ? void 0 : options.alwaysGenerateNew) && newAssignments.length > 0) {
-                const index = Math.floor(Math.random() * newAssignments.length);
-                return newAssignments[index];
-            }
+            // The db cache of the shared content is temporary disabled until the new shared content implementation is completed
+            // if (false) {
+            //   let query = this.supabase
+            //     .from('shared_content')
+            //     .select('*, scc:shared_content_completed(id, state)')
+            //     .eq('content_type', contentType)
+            //     .not('scc.state', 'in', '("completed","ongoing","hidden")')
+            //     .is('deleted_at', null);
+            //   if (options?.excludeIds?.length ?? 0 > 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.limit(30);
+            //   if (error) {
+            //     console.error('error fetching new assignments:', error);
+            //     throw new Error('error fetching new assignments');
+            //   }
+            //   // console.log('newAssignments:', newAssignments);
+            //   if (!options?.alwaysGenerateNew && newAssignments.length > 0) {
+            //     const index = Math.floor(Math.random() * newAssignments.length);
+            //     return newAssignments[index];
+            //   }
+            // }
             const instructions = yield this.generateNewAssignment(contentType, generatorInstructions, filter);
             console.log('instructions:', instructions);
             //create the shared content object

package/dist/controller/TranslationController.d.ts

@@ -4,7 +4,8 @@ import { ThirdPartyModule, TOptions } from 'i18next';
  */
 export declare class Translator {
     private currentLanguage;
-    private isInitialized;
+    private initializationState;
+    private initializationPromise;
     private i18n;
     constructor(initialLanguage: string);
     /**

package/dist/controller/TranslationController.js

@@ -13,8 +13,9 @@ import { createInstance } from 'i18next';
  */
 export class Translator {
     constructor(initialLanguage) {
-        this.isInitialized = false;
         this.currentLanguage = initialLanguage;
+        this.initializationState = 'not-inited';
+        this.initializationPromise = null;
     }
     /**
      * Initialize translator with user's language
@@ -22,21 +23,41 @@ export class Translator {
      */
     initialize() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.isInitialized)
+            // If already finished, return immediately
+            if (this.initializationState === 'finished') {
                 return;
-            const translations = yield this.fetchTranslations(this.currentLanguage);
-            const instance = createInstance({
-                lng: this.currentLanguage,
-                resources: {
-                    [this.currentLanguage]: {
-                        translation: translations,
-                    },
-                },
-                debug: window.location.hostname === 'localhost',
-            });
-            yield instance.init();
-            this.i18n = instance;
-            this.isInitialized = true;
+            }
+            // If currently initializing, wait for the existing initialization to complete
+            if (this.initializationState === 'initing' && this.initializationPromise) {
+                return this.initializationPromise;
+            }
+            // Start initialization
+            this.initializationState = 'initing';
+            // Create a promise that will be resolved when initialization completes
+            this.initializationPromise = (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const translations = yield this.fetchTranslations(this.currentLanguage);
+                    const instance = createInstance({
+                        lng: this.currentLanguage,
+                        resources: {
+                            [this.currentLanguage]: {
+                                translation: translations,
+                            },
+                        },
+                        debug: window.location.hostname === 'localhost',
+                    });
+                    yield instance.init();
+                    this.i18n = instance;
+                    this.initializationState = 'finished';
+                }
+                catch (error) {
+                    // Reset state on error so it can be retried
+                    this.initializationState = 'not-inited';
+                    this.initializationPromise = null;
+                    throw error;
+                }
+            }))();
+            return this.initializationPromise;
         });
     }
     getTranslationUrl(language) {
@@ -101,6 +122,6 @@ export class Translator {
      * Check if translator is initialized
      */
     isReady() {
-        return this.isInitialized;
+        return this.initializationState === 'finished';
     }
 }

package/dist/fromRimori/EventBus.js

@@ -67,7 +67,7 @@ export class EventBusHandler {
         }
         const event = this.createEvent(sender, topic, data, eventId);
         const handlers = this.getMatchingHandlers(event.topic);
-        handlers.forEach(handler => {
+        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;
@@ -79,7 +79,9 @@ export class EventBusHandler {
             this.logAndThrowError(false, `No handlers found for topic: ` + topic);
         }
         // If it's a response to a request
-        if (eventId && this.responseResolvers.has(eventId) && !skipResponseTrigger) {
+        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);
@@ -93,7 +95,7 @@ export class EventBusHandler {
      * @returns An EventListener object containing an off() method to unsubscribe the listeners.
      */
     on(topics, handler, ignoreSender = []) {
-        const ids = this.toArray(topics).map(topic => {
+        const ids = this.toArray(topics).map((topic) => {
             this.logIfDebug(`Subscribing to ` + topic, { ignoreSender });
             if (!this.validateTopic(topic)) {
                 this.logAndThrowError(true, `Invalid topic: ` + topic);
@@ -102,14 +104,33 @@ export class EventBusHandler {
                 this.listeners.set(topic, new Set());
             }
             const id = Math.floor(Math.random() * 10000000000);
-            // Type assertion to handle the generic type mismatch
-            const eventHandler = handler;
-            this.listeners.get(topic).add({ id, handler: eventHandler, ignoreSender });
-            this.logIfDebug(`Subscribed to ` + topic, { listenerId: id, ignoreSender });
+            // To prevent infinite loops and processing the same eventId multiple times
+            const blackListedEventIds = [];
+            const eventHandler = (data) => {
+                if (blackListedEventIds.some((item) => item.eventId === data.eventId && item.sender === data.sender)) {
+                    console.log("BLACKLISTED EVENT ID", data.eventId, data);
+                    return;
+                }
+                blackListedEventIds.push({
+                    eventId: data.eventId,
+                    sender: data.sender,
+                });
+                if (blackListedEventIds.length > 100) {
+                    blackListedEventIds.shift();
+                }
+                return handler(data);
+            };
+            this.listeners
+                .get(topic)
+                .add({ id, handler: eventHandler, ignoreSender });
+            this.logIfDebug(`Subscribed to ` + topic, {
+                listenerId: id,
+                ignoreSender,
+            });
             return btoa(JSON.stringify({ topic, id }));
         });
         return {
-            off: () => this.off(ids)
+            off: () => this.off(ids),
         };
     }
     /**
@@ -121,7 +142,7 @@ export class EventBusHandler {
      */
     respond(sender, topic, handler) {
         const topics = Array.isArray(topic) ? topic : [topic];
-        const listeners = topics.map(topic => {
+        const listeners = topics.map((topic) => {
             const blackListedEventIds = [];
             //To allow event communication inside the same plugin the sender needs to be ignored but the events still need to be checked for the same event just reaching the subscriber to prevent infinite loops
             const finalIgnoreSender = !topic.startsWith("self.") ? [sender] : [];
@@ -131,7 +152,7 @@ export class EventBusHandler {
                     return;
                 }
                 blackListedEventIds.push(data.eventId);
-                if (blackListedEventIds.length > 20) {
+                if (blackListedEventIds.length > 100) {
                     blackListedEventIds.shift();
                 }
                 const response = typeof handler === "function" ? yield handler(data) : handler;
@@ -139,11 +160,11 @@ export class EventBusHandler {
             }), finalIgnoreSender);
             this.logIfDebug(`Added respond listener ` + sender + " to topic " + topic, { listener, sender });
             return {
-                off: () => listener.off()
+                off: () => listener.off(),
             };
         });
         return {
-            off: () => listeners.forEach(listener => listener.off())
+            off: () => listeners.forEach((listener) => listener.off()),
         };
     }
     /**
@@ -169,13 +190,16 @@ export class EventBusHandler {
      * @param listenerIds - The ids of the listeners to unsubscribe from.
      */
     off(listenerIds) {
-        this.toArray(listenerIds).forEach(fullId => {
+        this.toArray(listenerIds).forEach((fullId) => {
             const { topic, id } = JSON.parse(atob(fullId));
             const listeners = this.listeners.get(topic) || new Set();
-            listeners.forEach(listener => {
+            listeners.forEach((listener) => {
                 if (listener.id === Number(id)) {
                     listeners.delete(listener);
-                    this.logIfDebug(`Removed listener ` + fullId, { topic, listenerId: id });
+                    this.logIfDebug(`Removed listener ` + fullId, {
+                        topic,
+                        listenerId: id,
+                    });
                 }
             });
         });
@@ -197,7 +221,7 @@ export class EventBusHandler {
             }
             const event = this.createEvent(sender, topic, data || {});
             this.logIfDebug(`Requesting data from ` + topic, { event });
-            return new Promise(resolve => {
+            return new Promise((resolve) => {
                 this.responseResolvers.set(event.eventId, (value) => resolve(value));
                 this.emitInternal(sender, topic, data || {}, event.eventId, true);
             });
@@ -240,10 +264,13 @@ export class EventBusHandler {
         }
         // Validate action part
         const validActions = ["request", "create", "update", "delete", "trigger"];
-        if (validActions.some(a => action.startsWith(a))) {
+        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(", "));
+        this.logAndThrowError(false, `Invalid event topic name. The action: ` +
+            action +
+            ". Must be or start with one of: " +
+            validActions.join(", "));
         return false;
     }
     logIfDebug(...args) {

package/dist/index.d.ts

@@ -11,7 +11,8 @@ export { Translator } from './controller/TranslationController';
 export type { TOptions } from 'i18next';
 export type { SharedContent, SharedContentObjectRequest } from './controller/SharedContentController';
 export type { Exercise } from './controller/ExerciseController';
-export type { UserInfo, Language } from './controller/SettingsController';
+export type { UserInfo, Language, UserRole } from './controller/SettingsController';
 export type { Message, ToolInvocation } from './controller/AIController';
 export type { TriggerAction } from './controller/ExerciseController';
 export type { MacroAccomplishmentPayload, MicroAccomplishmentPayload } from './controller/AccomplishmentController';
+export type { EventBusMessage } from './fromRimori/EventBus';

package/dist/plugin/CommunicationHandler.d.ts

@@ -26,6 +26,7 @@ export interface RimoriInfo {
     profile: UserInfo;
     mainPanelPlugin?: ActivePlugin;
     sidePanelPlugin?: ActivePlugin;
+    interfaceLanguage: string;
 }
 export declare class RimoriCommunicationHandler {
     private port;

package/dist/plugin/CommunicationHandler.js

@@ -26,15 +26,17 @@ export class RimoriCommunicationHandler {
     }
     initMessageChannel(worker = false) {
         const listener = (event) => {
-            console.log('[PluginController] window message', { origin: event.origin, data: event.data });
+            // console.log('[PluginController] window message', { origin: event.origin, data: event.data });
             const { type, pluginId, queryParams, rimoriInfo } = event.data || {};
             const [transferredPort] = event.ports || [];
             if (type !== 'rimori:init' || !transferredPort || pluginId !== this.pluginId) {
-                console.log('[PluginController] message ignored (not init or wrong plugin)', {
-                    type,
-                    pluginId,
-                    hasPort: !!transferredPort,
-                });
+                // console.log('[PluginController] message ignored (not init or wrong plugin)', {
+                //   type,
+                //   pluginId,
+                //   currentPluginId: this.pluginId,
+                //   hasPortProperty: !!transferredPort,
+                //   event
+                // });
                 return;
             }
             this.queryParams = queryParams || {};
@@ -182,7 +184,7 @@ export class RimoriCommunicationHandler {
                 else {
                     // In main thread context, use EventBus
                     const { data } = yield EventBus.request(this.pluginId, 'global.supabase.requestAccess');
-                    console.log({ data });
+                    // console.log({ data });
                     this.rimoriInfo = data;
                     this.supabase = createClient(this.rimoriInfo.url, this.rimoriInfo.key, {
                         accessToken: () => Promise.resolve(this.getToken()),

package/dist/plugin/Logger.d.ts

@@ -54,6 +54,7 @@ export declare class Logger {
     private getBrowserInfo;
     /**
      * Capture a screenshot of the current page.
+     * Dynamically imports html2canvas only in browser environments.
      * @returns Promise resolving to base64 screenshot or null if failed
      */
     private captureScreenshot;

package/dist/plugin/Logger.js

@@ -7,7 +7,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import html2canvas from 'html2canvas';
 /**
  * Singleton Logger class for Rimori client plugins.
  * Handles all logging levels, production filtering, and log transmission to Rimori.
@@ -242,17 +241,30 @@ export class Logger {
     }
     /**
      * Capture a screenshot of the current page.
+     * Dynamically imports html2canvas only in browser environments.
      * @returns Promise resolving to base64 screenshot or null if failed
      */
     captureScreenshot() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+            // Only attempt to capture screenshot in browser environments
+            if (typeof window === 'undefined' || typeof document === 'undefined') {
+                return null;
+            }
+            try {
+                // Dynamically import html2canvas only when window is available
+                // This allows tree-shaking for environments without window (e.g., Node.js)
+                const html2canvas = (yield import('html2canvas')).default;
                 const canvas = yield html2canvas(document.body);
                 const screenshot = canvas.toDataURL('image/png');
                 // this.originalConsole.log("screenshot captured", screenshot)
                 return screenshot;
             }
-            return null;
+            catch (error) {
+                // html2canvas may not be available or may fail to load
+                // Silently fail to avoid breaking logging functionality
+                this.originalConsole.warn('[Rimori Logger] Failed to capture screenshot:', error);
+                return null;
+            }
         });
     }
     /**