@rimori/client 1.1.9 → 1.2.0

package/src/cli/scripts/release/release-file-upload.ts

@@ -0,0 +1,138 @@
+import fs from 'fs';
+import path from 'path';
+import { Config } from './release.js';
+
+/**
+ * Upload all files from a directory and its subdirectories to the release function
+ * @param config - Configuration object
+ */
+export async function uploadDirectory(config: Config, release_id: string): Promise<void> {
+  const relativePath = './dist';
+
+  console.log(`📁 Preparing to upload files from ${relativePath}...`);
+
+  // Check if dist directory exists
+  try {
+    await fs.promises.access(relativePath);
+  } catch (e) {
+    throw new Error(`Directory ${relativePath} does not exist. Make sure to build your plugin first.`);
+  }
+  // Get all files recursively
+  const files = await getAllFiles(relativePath);
+
+  if (files.length === 0) {
+    console.log('⚠️ No files found to upload');
+    return;
+  }
+
+  console.log(`🚀 Uploading ${files.length} files...`);
+
+  // Create FormData
+  const formData = new FormData();
+
+  // Add version and release channel data
+  formData.append('version', config.version);
+  formData.append('release_channel', config.release_channel);
+  formData.append('plugin_id', config.plugin_id);
+
+  // Create path mapping with IDs as keys
+  const pathMapping: Record<string, string> = {};
+
+  for (let i = 0; i < files.length; i++) {
+    const filePath = files[i];
+    try {
+      const fileContent = await fs.promises.readFile(filePath);
+      const relativePath = path.relative('./dist', filePath);
+      const contentType = getContentType(filePath);
+
+      // Generate unique ID for this file
+      const fileId = `file_${i}`;
+
+      // Add to path mapping using ID as key
+      pathMapping[fileId] = relativePath;
+
+      // Create a Blob with the file content and content type
+      const blob = new Blob([fileContent], { type: contentType });
+
+      // Add file to FormData with ID_filename format
+      const fileName = `${fileId}_${path.basename(filePath)}`;
+      formData.append('files', blob, fileName);
+    } catch (error: any) {
+      console.error(`❌ Error reading file ${filePath}:`, error.message);
+      throw error;
+    }
+  }
+
+  // Add path mapping to FormData
+  formData.append('path_mapping', JSON.stringify(pathMapping));
+
+  // Upload to the release endpoint
+  const response = await fetch(`${config.domain}/release/${release_id}/files`, {
+    method: 'POST',
+    headers: { 'Authorization': `Bearer ${config.token}` },
+    body: formData,
+  });
+
+  if (response.ok) {
+    console.log('✅ Files uploaded successfully!');
+  } else {
+    const errorText = await response.text();
+    console.log('❌ File upload failed!');
+    console.log('Response:', errorText);
+    throw new Error(`File upload failed with status ${response.status}`);
+  }
+}
+
+/**
+ * Recursively get all files from a directory
+ */
+async function getAllFiles(dirPath: string): Promise<string[]> {
+  const files: string[] = [];
+
+  async function traverse(currentPath: string) {
+    const entries = await fs.promises.readdir(currentPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentPath, entry.name);
+
+      if (entry.isDirectory()) {
+        await traverse(fullPath);
+      } else if (entry.isFile()) {
+        files.push(fullPath);
+      }
+    }
+  }
+
+  await traverse(dirPath);
+  return files;
+}
+
+/**
+ * Get content type based on file extension
+ */
+function getContentType(filePath: string): string {
+  const ext = filePath.split('.').pop()?.toLowerCase();
+  const contentTypes: Record<string, string> = {
+    html: 'text/html',
+    css: 'text/css',
+    js: 'application/javascript',
+    json: 'application/json',
+    md: 'text/markdown',
+    txt: 'text/plain',
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    svg: 'image/svg+xml',
+    pdf: 'application/pdf',
+    ico: 'image/x-icon',
+    mp3: 'audio/mpeg',
+    wav: 'audio/wav',
+    ogg: 'audio/ogg',
+    m4a: 'audio/mp4',
+    webp: 'image/webp',
+  };
+  const contentType = contentTypes[ext || ''];
+  if (!contentType) throw new Error(`Unsupported file type: ${ext}`);
+  return contentType;
+}

package/src/cli/scripts/release/release.ts

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+/**
+ * Usage:
+ *   rimori-release <release_channel>
+ *
+ * Environment variables required:
+ *   RIMORI_TOKEN      - Your Rimori token
+ *   RIMORI_PLUGIN  - Your plugin ID
+ *
+ * Make sure to install dependencies:
+ *   npm install node-fetch form-data ts-node typescript
+ */
+
+import 'dotenv/config';
+import fs from 'fs';
+import path from 'path';
+import dbUpdate from './release-db-update.js';
+import { uploadDirectory } from './release-file-upload.js';
+import { releasePlugin, sendConfiguration } from './release-config-upload.js';
+
+// Read version from package.json
+const packageJson = JSON.parse(fs.readFileSync(path.resolve('./package.json'), 'utf8'));
+const { version, r_id: pluginId } = packageJson;
+
+const RIMORI_TOKEN = process.env.RIMORI_TOKEN;
+if (!RIMORI_TOKEN) throw new Error('RIMORI_TOKEN is not set');
+if (!pluginId) throw new Error('The plugin id (r_id) is not set in package.json');
+
+const [releaseChannel] = process.argv.slice(2);
+if (!releaseChannel) {
+  console.error('Usage: rimori-release <release_channel>');
+  process.exit(1);
+}
+
+const config = {
+  version,
+  release_channel: releaseChannel,
+  plugin_id: pluginId,
+  token: RIMORI_TOKEN,
+  domain: process.env.RIMORI_BACKEND_URL || "https://api.rimori.se",
+  rimori_client_version: packageJson.dependencies['@rimori/client'].replace('^', ''),
+}
+
+export type Config = typeof config;
+
+/**
+ * Main release process
+ */
+async function releaseProcess(): Promise<void> {
+  try {
+    console.log(`🚀 Releasing ${config.plugin_id} to ${config.release_channel}...`);
+    // First send the configuration
+    const release_id = await sendConfiguration(config);
+
+    await dbUpdate(config, release_id);
+
+    // Then upload the files
+    await uploadDirectory(config, release_id);
+
+    // Then release the plugin
+    await releasePlugin(config, release_id);
+  } catch (error: any) {
+    console.log("❌ Error:", error.message);
+    process.exit(1);
+  }
+}
+
+releaseProcess();

package/src/cli/types/DatabaseTypes.ts

@@ -0,0 +1,117 @@
+
+// Database table structure definitions
+
+/**
+ * Supported database column data types for table schema definitions.
+ */
+type DbColumnType = 'decimal' | 'integer' | 'text' | 'boolean' | 'json' | 'timestamp' | 'uuid';
+
+/**
+ * Foreign key relationship configuration with cascade delete support.
+ * Defines a relationship where the source record is deleted when the destination record is deleted.
+ */
+interface ForeignKeyRelation {
+  /** The target table that this column references */
+  references_table: string;
+  /** The target column in the referenced table (defaults to 'id') */
+  references_column?: string;
+  /** Whether to cascade delete when the referenced record is deleted */
+  on_delete_cascade: boolean;
+}
+
+/**
+ * Database column definition with support for types, constraints, and relationships.
+ */
+export interface DbColumnDefinition {
+  /** The data type of the column */
+  type: DbColumnType;
+  /** Human-readable description of the column's purpose */
+  description: string;
+  /** Whether the column can contain null values */
+  nullable?: boolean;
+  /** Whether the column has a unique constraint */
+  unique?: boolean;
+  /** Default value for the column. can also use sql functions like now(), auth.uid() or gen_random_uuid() */
+  default_value?: string | number | boolean;
+  /** Array of allowed values for enumerated columns */
+  // enum?: string[];
+  /** Foreign key relationship configuration */
+  foreign_key?: ForeignKeyRelation;
+  /** The name of the column before it was renamed. */
+  old_name?: string;
+  /** Whether the column is deprecated. The column gets renamed to column_name_old. To fully remove the column, first set deprecated to true and then after a release, remove the column from the table definition. */
+  deprecated?: boolean;
+  /** Whether the column is a primary key */
+  // primary_key?: boolean;
+  /** Restrictions for the column. If the column is restricted, the permission is further restricted. E.g. if the column is restricted to user, then the user can only read the column if they have the right permission.
+   * Example: Denying users to update the column, but allowing the moderator to update the column.
+  */
+  restrict?: {
+    /** Restrictions for the user */
+    user: Partial<Omit<DbPermissionDefinition, 'delete'>>,
+    /** Restrictions for the moderator */
+    moderator?: Partial<Omit<DbPermissionDefinition, 'delete'>>,
+    /** Restrictions for the maintainer */
+    // maintainer?: Partial<DbPermissionDefinition>,
+  }
+}
+
+/**
+ * Base table structure that all database tables inherit.
+ * Includes standard audit fields for tracking creation and ownership.
+ */
+interface BaseTableStructure {
+  /** Unique identifier for the record */
+  id: DbColumnDefinition;
+  /** Timestamp when the record was created */
+  created_at: DbColumnDefinition;
+  /** ID of the user who created the record */
+  created_by: DbColumnDefinition;
+}
+
+/**
+ * Complete database table schema definition.
+ * Defines the structure, constraints, and relationships for a database table.
+ */
+export interface DbTableDefinition {
+  /** Name of the database table */
+  table_name: string;
+  /** Description of the table's purpose and usage */
+  description: string;
+  /** Permissions for the table */
+  permissions: {
+    user: DbPermissionDefinition,
+    moderator?: DbPermissionDefinition,
+    // maintainer?: DbPermissionDefinition,
+  };
+  /** Column definitions for the table */
+  columns: {
+    [column_name: string]: DbColumnDefinition;
+  };
+}
+
+/**
+ * Permission definition for a database table.
+ * NONE means the action is not allowed.
+ * OWN means only do the action on your own records.
+ * ALL means do the action on all records.
+ *
+ * Defines the permissions for a database table.
+ */
+export type DbPermission = "NONE" | "OWN" | "ALL";
+
+/**
+ * Permission definition for a database table.
+ * Defines the permissions for a database table.
+ */
+export interface DbPermissionDefinition {
+  read: DbPermission;
+  insert: DbPermission;
+  update: DbPermission;
+  delete: DbPermission;
+}
+
+/**
+ * Full table definition that includes automatically generated fields.
+ */
+export type FullTable<T extends Record<string, DbColumnDefinition>> = T & BaseTableStructure;

package/src/components/ai/Assistant.tsx

@@ -16,7 +16,7 @@ interface Props {
 
 export function AssistantChat({ avatarImageUrl, voiceId, onComplete, autoStartConversation }: Props) {
     const [oralCommunication, setOralCommunication] = React.useState(true);
-    const { llm, event } = usePlugin();
+    const { ai: llm, event } = usePlugin();
     const sender = useMemo(() => new MessageSender(llm.getVoice, voiceId), []);
     const { messages, append, isLoading, setMessages } = useChat();
 
@@ -50,16 +50,16 @@ export function AssistantChat({ avatarImageUrl, voiceId, onComplete, autoStartCo
 
     useEffect(() => {
         console.log("lastMessage", lastMessage);
-        const toolInvocations = lastMessage?.toolInvocations;
+        const toolInvocations = lastMessage?.toolCalls;
         if (toolInvocations && toolInvocations.length > 0) {
             console.log("toolInvocations", toolInvocations);
             onComplete(toolInvocations[0].args);
         }
     }, [lastMessage]);
 
-    if (lastMessage?.toolInvocations && lastMessage.toolInvocations.length > 0) {
+    if (lastMessage?.toolCalls && lastMessage.toolCalls.length > 0) {
         console.log("lastMessage test2", lastMessage);
-        const args = lastMessage.toolInvocations[0].args;
+        const args = lastMessage.toolCalls[0].args;
 
         const success = args.explanationUnderstood === "TRUE" || args.studentKnowsTopic === "TRUE";
 

package/src/components/ai/Avatar.tsx

@@ -2,7 +2,7 @@ import { useEffect, useMemo, useState } from 'react';
 import { VoiceRecorder } from './EmbeddedAssistent/VoiceRecoder';
 import { MessageSender } from './EmbeddedAssistent/TTS/MessageSender';
 import { CircleAudioAvatar } from './EmbeddedAssistent/CircleAudioAvatar';
-import { Tool } from '../../controller/AIController';
+import { Tool } from '../../fromRimori/PluginTypes';
 import { useChat } from '../../hooks/UseChatHook';
 import { usePlugin } from '../../components';
 import { getFirstMessages } from './utils';
@@ -16,13 +16,23 @@ interface Props {
   isDarkTheme?: boolean;
   children?: React.ReactNode;
   autoStartConversation?: FirstMessages;
+  className?: string;
 }
 
-export function Avatar({ avatarImageUrl, voiceId, agentTools, autoStartConversation, children, isDarkTheme = false, circleSize = "300px" }: Props) {
-  const { llm, event } = usePlugin();
+export function Avatar({
+  avatarImageUrl,
+  voiceId,
+  agentTools,
+  autoStartConversation,
+  children,
+  isDarkTheme = false,
+  circleSize = "300px",
+  className
+}: Props) {
+  const { ai, event } = usePlugin();
   const [agentReplying, setAgentReplying] = useState(false);
   const [isProcessingMessage, setIsProcessingMessage] = useState(false);
-  const sender = useMemo(() => new MessageSender(llm.getVoice, voiceId), []);
+  const sender = useMemo(() => new MessageSender(ai.getVoice, voiceId), [voiceId]);
   const { messages, append, isLoading, lastMessage, setMessages } = useChat(agentTools);
 
   useEffect(() => {
@@ -48,16 +58,21 @@ export function Avatar({ avatarImageUrl, voiceId, agentTools, autoStartConversat
     } else if (autoStartConversation.userMessage) {
       append([{ role: 'user', content: autoStartConversation.userMessage, id: messages.length.toString() }]);
     }
-  }, []);
+  }, [autoStartConversation]);
 
   useEffect(() => {
     if (lastMessage?.role === 'assistant') {
       sender.handleNewText(lastMessage.content, isLoading);
+      if (lastMessage.toolCalls) {
+        console.log("unlocking mic",lastMessage)
+        setAgentReplying(false);
+        setIsProcessingMessage(false);
+      }
     }
   }, [lastMessage, isLoading]);
 
   return (
-    <div className='pb-8'>
+    <div className={`md:pb-8 ${className || ''}`}>
       <CircleAudioAvatar
         width={circleSize}
         className='mx-auto'
@@ -65,9 +80,11 @@ export function Avatar({ avatarImageUrl, voiceId, agentTools, autoStartConversat
         isDarkTheme={isDarkTheme} />
       {children}
       <VoiceRecorder
-        iconSize='300'
+        iconSize='30'
+        className='w-16 h-16 shadow-lg rounded-full bg-gray-400 dark:bg-gray-800'
         disabled={agentReplying}
         loading={isProcessingMessage}
+        enablePushToTalk={true}
         onVoiceRecorded={(message) => {
           setAgentReplying(true);
           append([{ role: 'user', content: "Message(" + Math.floor((messages.length + 1) / 2) + "): " + message, id: messages.length.toString() }]);

package/src/components/ai/EmbeddedAssistent/CircleAudioAvatar.tsx

@@ -1,5 +1,5 @@
 import { useEffect, useRef } from 'react';
-import { EventBus, EventBusMessage } from '../../../plugin/fromRimori/EventBus';
+import { EventBus, EventBusMessage } from '../../../fromRimori/EventBus';
 
 interface CircleAudioAvatarProps {
   width?: string;

package/src/components/ai/EmbeddedAssistent/VoiceRecoder.tsx

@@ -7,16 +7,18 @@ interface Props {
   className?: string;
   disabled?: boolean;
   loading?: boolean;
+  enablePushToTalk?: boolean;
   onRecordingStatusChange: (running: boolean) => void;
   onVoiceRecorded: (message: string) => void;
 }
 
-export const VoiceRecorder = forwardRef(({ onVoiceRecorded, iconSize, className, disabled, loading, onRecordingStatusChange }: Props, ref) => {
+export const VoiceRecorder = forwardRef(({ onVoiceRecorded, iconSize, className, disabled, loading, onRecordingStatusChange, enablePushToTalk = false }: Props, ref) => {
   const [isRecording, setIsRecording] = useState(false);
+  const [internalIsProcessing, setInternalIsProcessing] = useState(false);
   const mediaRecorderRef = useRef<MediaRecorder | null>(null);
   const audioChunksRef = useRef<Blob[]>([]);
   const mediaStreamRef = useRef<MediaStream | null>(null);
-  const { llm } = usePlugin();
+  const { ai: llm } = usePlugin();
 
   // Ref for latest onVoiceRecorded callback
   const onVoiceRecordedRef = useRef(onVoiceRecorded);
@@ -38,7 +40,11 @@ export const VoiceRecorder = forwardRef(({ onVoiceRecorded, iconSize, className,
       const audioBlob = new Blob(audioChunksRef.current);
       audioChunksRef.current = [];
 
-      onVoiceRecordedRef.current(await llm.getTextFromVoice(audioBlob));
+
+      setInternalIsProcessing(true);
+      const text = await llm.getTextFromVoice(audioBlob);
+      setInternalIsProcessing(false);
+      onVoiceRecordedRef.current(text);
     };
 
     mediaRecorder.start();
@@ -67,6 +73,8 @@ export const VoiceRecorder = forwardRef(({ onVoiceRecorded, iconSize, className,
   const spacePressedRef = useRef(false);
 
   useEffect(() => {
+    if (!enablePushToTalk) return;
+
     const handleKeyDown = async (event: KeyboardEvent) => {
       if (event.code === 'Space' && !spacePressedRef.current) {
         spacePressedRef.current = true;
@@ -85,14 +93,14 @@ export const VoiceRecorder = forwardRef(({ onVoiceRecorded, iconSize, className,
       window.removeEventListener('keydown', handleKeyDown);
       window.removeEventListener('keyup', handleKeyUp);
     };
-  }, []);
+  }, [enablePushToTalk]);
 
   return (
-    <button className={"w-16 h-16 flex text-4xl shadow-lg flex-row justify-center items-center rounded-full mx-auto bg-gray-400 dark:bg-gray-800 pl-[6px] disabled:opacity-50 " + className}
+    <button className={"flex flex-row justify-center items-center rounded-full mx-auto disabled:opacity-50 " + className}
       onClick={isRecording ? stopRecording : startRecording}
-      disabled={disabled || loading}>
-      {loading ? <FaSpinner className="animate-spin mr-[6px]" /> :
-        <FaMicrophone size={iconSize} className={"h-7 w-7 mr-2 " + (isRecording ? "text-red-600" : "")} />
+      disabled={disabled || loading || internalIsProcessing}>
+      {loading || internalIsProcessing ? <FaSpinner className="animate-spin" /> :
+        <FaMicrophone size={iconSize} className={(isRecording ? "text-red-600" : "")} />
       }
     </button>
   );

package/src/components/ai/utils.ts

@@ -17,7 +17,5 @@ export function getFirstMessages(instructions: FirstMessages): any[] {
       messages.push({ id: '3', role: 'assistant', content: instructions.assistantMessage });
   }
 
-  console.log("getFirstMessages", messages);
-
   return messages;
 }

package/src/components/audio/Playbutton.tsx

@@ -2,7 +2,7 @@ import React, { useState, useEffect } from 'react';
 import { FaPlayCircle, FaStopCircle } from "react-icons/fa";
 import { usePlugin } from "../../providers/PluginProvider";
 import { Spinner } from '../Spinner';
-import { EventBus } from '../../plugin/fromRimori/EventBus';
+import { EventBus } from '../../fromRimori/EventBus';
 
 type AudioPlayerProps = {
     text: string;
@@ -34,7 +34,7 @@ export const AudioPlayer: React.FC<AudioPlayerProps> = ({
     const [speed, setSpeed] = useState(initialSpeed);
     const [isPlaying, setIsPlaying] = useState(false);
     const [isLoading, setIsLoading] = useState(false);
-    const { llm } = usePlugin();
+    const { ai } = usePlugin();
 
     useEffect(() => {
         if (!playListenerEvent) return;
@@ -52,7 +52,7 @@ export const AudioPlayer: React.FC<AudioPlayerProps> = ({
     const generateAudio = async () => {
         setIsLoading(true);
 
-        const blob = await llm.getVoice(text, voice || (language ? "aws_default" : "openai_alloy"), 1, language);
+        const blob = await ai.getVoice(text, voice || (language ? "aws_default" : "openai_alloy"), 1, language);
         setAudioUrl(URL.createObjectURL(blob));
         setIsLoading(false);
     };

package/src/{core → components}/components/ContextMenu.tsx

@@ -1,7 +1,7 @@
 import React, { useState, useEffect, useRef } from "react";
-import { EventBus } from "../../plugin/fromRimori/EventBus";
+import { EventBus } from "../../fromRimori/EventBus";
 import { RimoriClient } from "../../plugin/RimoriClient";
-import { MenuEntry } from "../../plugin/fromRimori/PluginTypes";
+import { MenuEntry } from "../../fromRimori/PluginTypes";
 
 export interface Position {
   x: number,
@@ -105,7 +105,7 @@ const ContextMenu = ({ client }: { client: RimoriClient }) => {
         <MenuEntryItem key={index} icon={action.icon} text={action.text} onClick={() => {
           setIsOpen(false);
           window.getSelection()?.removeAllRanges();
-          client.event.emitSidebarAction(action.pluginId, action.actionKey, position.text);
+          client.event.emitSidebarAction(action.plugin_id, action.action_key, position.text);
         }} />
       ))}
     </div>

package/src/components.ts

@@ -1,11 +1,11 @@
 // React components and hooks exports
-export * from "./components/MarkdownEditor";
+export * from "./components/ai/Assistant";
+export * from "./components/ai/Avatar";
+export * from "./components/ai/EmbeddedAssistent/VoiceRecoder";
+export * from "./components/audio/Playbutton";
 export * from "./components/CRUDModal";
+export * from "./components/MarkdownEditor";
 export * from "./components/Spinner";
-export * from "./components/audio/Playbutton";
 export * from "./hooks/UseChatHook";
 export * from "./plugin/ThemeSetter";
-export * from "./providers/PluginProvider"; 
-export * from "./components/ai/Avatar";
-export * from "./components/ai/Assistant";
-export * from "./types/Actions";
+export * from "./providers/PluginProvider";