@rimori/client 2.5.37 → 2.5.38-next.0

package/dist/cli/scripts/release/release-config-upload.js

@@ -56,6 +56,9 @@ export async function sendConfiguration(config) {
             rimori_client_version: config.rimori_client_version,
             provided_languages: availableLanguages.join(','),
         };
+        if (config.dev_sync) {
+            requestBody.update_existing = true;
+        }
         try {
             const response = await fetch(`${config.domain}/release`, {
                 method: 'POST',

package/dist/cli/scripts/release/release.d.ts

@@ -18,6 +18,7 @@ declare const config: {
     token: string;
     domain: string;
     rimori_client_version: any;
+    dev_sync: boolean;
 };
 export type Config = typeof config;
 export {};

package/dist/cli/scripts/release/release.js

@@ -29,9 +29,15 @@ if (!pluginId) {
     console.error('Error: The plugin id (r_id) is not set in package.json');
     process.exit(1);
 }
-const [releaseChannel] = process.argv.slice(2);
+const cliArgs = process.argv.slice(2);
+const devSync = cliArgs.includes('--dev-sync');
+const releaseChannel = cliArgs.find((a) => !a.startsWith('--'));
 if (!releaseChannel) {
-    console.error('Usage: rimori-release <release_channel>');
+    console.error('Usage: rimori-release <release_channel> [--dev-sync]');
+    process.exit(1);
+}
+if (devSync && releaseChannel !== 'alpha') {
+    console.error('--dev-sync is only allowed with the alpha channel');
     process.exit(1);
 }
 const config = {
@@ -41,19 +47,30 @@ const config = {
     token: RIMORI_TOKEN,
     domain: process.env.RIMORI_BACKEND_URL || 'https://api.rimori.se',
     rimori_client_version: packageJson.dependencies['@rimori/client'].replace('^', ''),
+    dev_sync: devSync,
 };
 /**
  * Main release process
  */
 async function releaseProcess() {
     try {
-        console.log(`🚀 Releasing ${config.plugin_id} to ${config.release_channel}...`);
+        if (config.dev_sync) {
+            console.log(`⚡ Dev-sync ${config.plugin_id} → existing alpha release`);
+        }
+        else {
+            console.log(`🚀 Releasing ${config.plugin_id} to ${config.release_channel}...`);
+        }
         console.log(`📡 Deploying to: ${config.domain}`);
         // First send the configuration
         const release_id = await sendConfiguration(config);
         // Upload prompts (if prompts.config.ts exists)
         await promptsUpload(config, release_id);
         await dbUpdate(config, release_id);
+        // Dev-sync only pushes metadata — skip bundle upload and finalize.
+        if (config.dev_sync) {
+            console.log('✅ Dev-sync complete');
+            return;
+        }
         // Then upload the files
         await uploadDirectory(config, release_id);
         // Then release the plugin

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

@@ -16,7 +16,12 @@
  *  3. The column MUST be named 'embedding' and only one per table is allowed.
  *  4. Requires `source_column` — the column whose content is embedded async on insert.
  */
-type DbColumnType = 'decimal' | 'integer' | 'text' | 'boolean' | 'json' | 'timestamp' | 'uuid' | 'markdown' | 'vector';
+/**
+ * 'image', 'audio', 'video' and 'file' are stored as `text` (URL) in the database.
+ * The migration system adds an `updated_at` trigger and registers the column for
+ * the asset-refs cron, which links rows to bucket files and deletes orphans.
+ */
+type DbColumnType = 'decimal' | 'integer' | 'text' | 'boolean' | 'json' | 'timestamp' | 'uuid' | 'markdown' | 'vector' | 'image' | 'audio' | 'video' | 'file';
 /**
  * Foreign key relationship configuration with cascade delete support.
  * Defines a relationship where the source record is deleted when the destination record is deleted.

package/dist/index.d.ts

@@ -21,4 +21,5 @@ export { TIER_ORDER, ROLE_ORDER } from './plugin/module/PluginModule';
 export type { SharedContent, BasicSharedContent, ContentStatus } from './plugin/module/SharedContentController';
 export type { MacroAccomplishmentPayload, MicroAccomplishmentPayload } from './controller/AccomplishmentController';
 export { StorageModule } from './plugin/module/StorageModule';
+export { AssetsModule, type AssetKind } from './plugin/module/AssetsModule';
 export type { PublicityLevel } from './plugin/module/DbModule';

package/dist/index.js

@@ -13,3 +13,4 @@ export { AudioController } from './controller/AudioController';
 export { Translator } from './controller/TranslationController';
 export { TIER_ORDER, ROLE_ORDER } from './plugin/module/PluginModule';
 export { StorageModule } from './plugin/module/StorageModule';
+export { AssetsModule } from './plugin/module/AssetsModule';

package/dist/plugin/RimoriClient.d.ts

@@ -6,6 +6,7 @@ import { EventModule } from './module/EventModule';
 import { AIModule } from './module/AIModule';
 import { ExerciseModule } from './module/ExerciseModule';
 import { StorageModule } from './module/StorageModule';
+import { AssetsModule } from './module/AssetsModule';
 import { EventBusHandler } from '../fromRimori/EventBus';
 export declare class RimoriClient {
     private static instance;
@@ -18,6 +19,8 @@ export declare class RimoriClient {
     exercise: ExerciseModule;
     /** Upload and manage images stored in Supabase via the backend. */
     storage: StorageModule;
+    /** Upload assets (image/audio/video/file) backing asset-typed db.config columns. */
+    assets: AssetsModule;
     /** The EventBus instance used by this client. In federation mode this is a per-plugin instance. */
     eventBus: EventBusHandler;
     private constructor();

package/dist/plugin/RimoriClient.js

@@ -7,6 +7,7 @@ import { EventModule } from './module/EventModule';
 import { AIModule } from './module/AIModule';
 import { ExerciseModule } from './module/ExerciseModule';
 import { StorageModule } from './module/StorageModule';
+import { AssetsModule } from './module/AssetsModule';
 import { PostgrestClient } from '@supabase/postgrest-js';
 import { EventBus, EventBusHandler } from '../fromRimori/EventBus';
 export class RimoriClient {
@@ -20,6 +21,8 @@ export class RimoriClient {
     exercise;
     /** Upload and manage images stored in Supabase via the backend. */
     storage;
+    /** Upload assets (image/audio/video/file) backing asset-typed db.config columns. */
+    assets;
     /** The EventBus instance used by this client. In federation mode this is a per-plugin instance. */
     eventBus;
     constructor(controller, supabase, info, eventBus) {
@@ -35,6 +38,7 @@ export class RimoriClient {
         this.plugin = new PluginModule(supabase, controller, info, this.ai);
         this.exercise = new ExerciseModule(supabase, controller, info, this.event);
         this.storage = new StorageModule(controller);
+        this.assets = new AssetsModule(controller);
         //only init logger in workers and on main plugin pages
         if (this.plugin.applicationMode !== 'sidebar') {
             Logger.getInstance(this);

package/dist/plugin/module/AIModule.d.ts

@@ -110,6 +110,19 @@ export declare class AIModule {
      * A warning is logged to the console in this case.
      */
     getVoice(text: string, voice?: string, speed?: number, language?: string, cache?: boolean, instructions?: string): Promise<Blob>;
+    /**
+     * Generate an image from a text prompt using AI.
+     * @param params.prompt The prompt describing the image to generate.
+     * @param params.cache Whether to cache the result by prompt hash (default: true).
+     * @returns `{ url, cached }` where `url` is either a data URL or a stored CDN URL.
+     */
+    getImage(params: {
+        prompt: string;
+        cache?: boolean;
+    }): Promise<{
+        url: string;
+        cached: boolean;
+    }>;
     /**
      * Convert voice audio to text using AI.
      * @param file The audio file to convert.

package/dist/plugin/module/AIModule.js

@@ -115,6 +115,27 @@ export class AIModule {
             }),
         }).then((r) => r.blob());
     }
+    /**
+     * Generate an image from a text prompt using AI.
+     * @param params.prompt The prompt describing the image to generate.
+     * @param params.cache Whether to cache the result by prompt hash (default: true).
+     * @returns `{ url, cached }` where `url` is either a data URL or a stored CDN URL.
+     */
+    async getImage(params) {
+        const { prompt, cache = true } = params;
+        const response = await this.controller.fetchBackend('/ai/image', {
+            method: 'POST',
+            body: JSON.stringify({
+                prompt,
+                cache,
+                session_token_id: this.sessionTokenId ?? undefined,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to generate image: ${response.status} ${response.statusText}`);
+        }
+        return response.json();
+    }
     /**
      * Convert voice audio to text using AI.
      * @param file The audio file to convert.

package/dist/plugin/module/AssetsModule.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Assets module for the `plugin-assets` Supabase bucket.
+ *
+ * Use this to upload files (image|audio|video|file) whose URL is stored in a
+ * matching `type: 'image' | 'audio' | 'video' | 'file'` column in db.config.ts.
+ *
+ * Lifecycle is automatic: the backend asset-refs cron links the upload to the
+ * row whose column value matches the returned URL (within ~30 minutes), and
+ * deletes the file when the row is removed or the column is replaced/cleared.
+ * No plugin-side confirm or delete call is needed.
+ *
+ * For markdown editor images (embedded as `![](url)` in markdown text), use
+ * `plugin.storage.uploadImage` instead — that has a different lifecycle (regex
+ * scan over markdown bodies) and lives in the separate `plugin-images` bucket.
+ */
+import { RimoriCommunicationHandler } from '../CommunicationHandler';
+export type AssetKind = 'image' | 'audio' | 'video' | 'file';
+export declare class AssetsModule {
+    private readonly controller;
+    constructor(controller: RimoriCommunicationHandler);
+    /**
+     * Upload a blob as an asset of the given kind.
+     *
+     * @returns `{ data: { url, path } }` on success, `{ error }` on failure.
+     *   Store `url` in the matching asset-typed column on your row. The cron
+     *   will pick it up on the next tick and confirm the ref.
+     */
+    upload(blob: Blob, options: {
+        kind: AssetKind;
+        filename?: string;
+    }): Promise<{
+        data: {
+            url: string;
+            path: string;
+        };
+        error?: undefined;
+    } | {
+        data?: undefined;
+        error: Error;
+    }>;
+}

package/dist/plugin/module/AssetsModule.js

@@ -0,0 +1,34 @@
+export class AssetsModule {
+    controller;
+    constructor(controller) {
+        this.controller = controller;
+    }
+    /**
+     * Upload a blob as an asset of the given kind.
+     *
+     * @returns `{ data: { url, path } }` on success, `{ error }` on failure.
+     *   Store `url` in the matching asset-typed column on your row. The cron
+     *   will pick it up on the next tick and confirm the ref.
+     */
+    async upload(blob, options) {
+        const formData = new FormData();
+        const filename = options.filename ?? `asset.${options.kind}`;
+        formData.append('file', blob, filename);
+        formData.append('kind', options.kind);
+        try {
+            const response = await this.controller.fetchBackend('/plugin-assets/upload', {
+                method: 'POST',
+                body: formData,
+            });
+            if (!response.ok) {
+                const body = (await response.json().catch(() => ({})));
+                return { error: new Error(body.message ?? `Upload failed (${response.status})`) };
+            }
+            const result = (await response.json());
+            return { data: result };
+        }
+        catch (err) {
+            return { error: err instanceof Error ? err : new Error(String(err)) };
+        }
+    }
+}

package/dist/plugin/module/SharedContentController.d.ts

@@ -1,8 +1,10 @@
 import { ObjectTool } from '../../fromRimori/PluginTypes';
 import { SupabaseClient } from '../CommunicationHandler';
 import { RimoriClient } from '../RimoriClient';
+import { LanguageLevel } from '../../utils/difficultyConverter';
 export type SharedContent<T> = BasicSharedContent & T;
 export type ContentStatus = 'featured' | 'community' | 'unverified';
+export type SharedContentSkillType = 'grammar' | 'reading' | 'writing' | 'speaking' | 'listening' | 'understanding';
 export interface BasicSharedContent {
     id: string;
     title: string;
@@ -12,6 +14,7 @@ export interface BasicSharedContent {
     created_at: string;
     guild_id: string | null;
     lang_id: string | null;
+    skill_level: LanguageLevel;
 }
 export interface SharedContentCompletionState {
     content_id: string;
@@ -44,7 +47,7 @@ export declare class SharedContentController {
      */
     getNew<T>(params: {
         table: string;
-        skillType: 'grammar' | 'reading' | 'writing' | 'speaking' | 'listening' | 'understanding';
+        skillType: SharedContentSkillType;
         placeholders?: Record<string, string>;
         filter?: Record<string, {
             filterType: 'rag' | 'exact' | 'exclude';
@@ -129,11 +132,15 @@ export declare class SharedContentController {
     getAll<T = any>(tableName: string, limit?: number): Promise<SharedContent<T>[]>;
     /**
      * Create new shared content manually.
+     * Auto-fills `skill_level` from the user's current `skill_level_{skillType}` setting
+     * so callers don't have to wire it up themselves (the column is NOT NULL on every
+     * shared-content table).
      * @param tableName - Name of the shared content table
+     * @param skillType - Skill this content trains; selects which user skill level to record
      * @param content - Content to create
      * @returns Created content
      */
-    create<T = any>(tableName: string, content: Omit<SharedContent<T>, 'id' | 'created_at' | 'created_by'>): Promise<SharedContent<T>>;
+    create<T = any>(tableName: string, skillType: SharedContentSkillType, content: Omit<SharedContent<T>, 'id' | 'created_at' | 'created_by' | 'skill_level'>): Promise<SharedContent<T>>;
     /**
      * Update existing shared content via backend.
      * If content was already validated (community/featured) and user is not a moderator,

package/dist/plugin/module/SharedContentController.js

@@ -226,13 +226,23 @@ export class SharedContentController {
     }
     /**
      * Create new shared content manually.
+     * Auto-fills `skill_level` from the user's current `skill_level_{skillType}` setting
+     * so callers don't have to wire it up themselves (the column is NOT NULL on every
+     * shared-content table).
      * @param tableName - Name of the shared content table
+     * @param skillType - Skill this content trains; selects which user skill level to record
      * @param content - Content to create
      * @returns Created content
      */
-    async create(tableName, content) {
+    async create(tableName, skillType, content) {
         const fullTableName = this.getTableName(tableName);
-        const { data, error } = await this.supabase.from(fullTableName).insert(content).select().single();
+        const userInfo = this.rimoriClient.plugin.getUserInfo();
+        const skillLevel = userInfo[`skill_level_${skillType}`];
+        const { data, error } = await this.supabase
+            .from(fullTableName)
+            .insert({ ...content, skill_level: skillLevel })
+            .select()
+            .single();
         if (error) {
             console.error('Error creating shared content:', error);
             throw new Error('Error creating shared content');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimori/client",
-  "version": "2.5.37",
+  "version": "2.5.38-next.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {