@rimori/client 1.1.10 → 1.3.0

package/dist/cli/scripts/init/tailwind-config.js

@@ -0,0 +1,56 @@
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Updates the tailwind.config.ts file to set darkMode to "class" and add the Rimori client package to content.
+ */
+export function updateTailwindConfig() {
+    console.log('Updating Tailwind CSS configuration...');
+    const tailwindConfigPath = path.resolve('./tailwind.config.ts');
+    if (!fs.existsSync(tailwindConfigPath)) {
+        console.log('Warning: tailwind.config.ts not found, skipping Tailwind CSS update');
+        return;
+    }
+    try {
+        const configContent = fs.readFileSync(tailwindConfigPath, 'utf8');
+        let updatedContent = configContent;
+        // Set darkMode to "class" if it exists, otherwise add it
+        if (updatedContent.includes('darkMode:')) {
+            updatedContent = updatedContent.replace(/darkMode:\s*\[?"[^"]*"?\]?,?/g, 'darkMode: ["class"],');
+        }
+        else {
+            // Add darkMode after the opening brace
+            updatedContent = updatedContent.replace(/export default \{/, 'export default {\n  darkMode: ["class"],');
+        }
+        // Add Rimori client package to content array if not already present
+        if (!updatedContent.includes('node_modules/@rimori/client')) {
+            // Find the content array and add the Rimori client path
+            if (updatedContent.includes('content:')) {
+                // More precise regex to handle the content array properly
+                updatedContent = updatedContent.replace(/(content:\s*\[)([\s\S]*?)(\])/, (match, start, content, end) => {
+                    // Clean up any existing double commas first
+                    let cleanContent = content.replace(/,\s*,/g, ',');
+                    // Remove trailing comma and whitespace
+                    cleanContent = cleanContent.replace(/,\s*$/, '');
+                    // Add the new path with proper formatting
+                    const newPath = '"node_modules/@rimori/client/dist/components/**/*.{js,jsx}"';
+                    // If content is not empty, add comma before new entry
+                    if (cleanContent.trim()) {
+                        return `${start}${cleanContent},\n    ${newPath}\n  ${end}`;
+                    }
+                    else {
+                        return `${start}\n    ${newPath}\n  ${end}`;
+                    }
+                });
+            }
+            else {
+                // Add content array if it doesn't exist
+                updatedContent = updatedContent.replace(/darkMode: \["class"\],/, 'darkMode: ["class"],\n  content: [\n    "./src/**/*.{js,jsx,ts,tsx}",\n    "node_modules/@rimori/client/dist/components/**/*.{js,jsx}"\n  ],');
+            }
+        }
+        fs.writeFileSync(tailwindConfigPath, updatedContent, 'utf8');
+        console.log('✅ Tailwind CSS configuration updated');
+    }
+    catch (error) {
+        console.warn(`Warning: Could not update tailwind.config.ts: ${error instanceof Error ? error.message : error}`);
+    }
+}

package/dist/cli/scripts/init/vite-config.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Updates the vite.config.ts file to set the base property.
+ * @param param
+ * @param param.basePath - The base path to set in vite config (defaults to './')
+ * @param param.configPath - Path to the vite.config.ts file (defaults to './vite.config.ts')
+ * @throws {Error} if vite.config.ts file is not found or cannot be modified.
+ */
+export declare function updateViteConfigBase({ basePath, configPath }?: {
+    basePath?: string;
+    configPath?: string;
+}): void;
+/**
+ * Reads the current base value from vite.config.ts.
+ * @param param
+ * @param param.configPath - Path to the vite.config.ts file (defaults to './vite.config.ts')
+ * @returns The current base value or null if not found.
+ */
+export declare function getCurrentViteBase({ configPath }?: {
+    configPath?: string;
+}): string | null;

package/dist/cli/scripts/init/vite-config.js

@@ -0,0 +1,54 @@
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Updates the vite.config.ts file to set the base property.
+ * @param param
+ * @param param.basePath - The base path to set in vite config (defaults to './')
+ * @param param.configPath - Path to the vite.config.ts file (defaults to './vite.config.ts')
+ * @throws {Error} if vite.config.ts file is not found or cannot be modified.
+ */
+export function updateViteConfigBase({ basePath = './', configPath = './vite.config.ts' } = {}) {
+    const viteConfigPath = path.resolve(configPath);
+    if (!fs.existsSync(viteConfigPath)) {
+        throw new Error(`vite.config.ts not found at ${viteConfigPath}`);
+    }
+    let configContent = fs.readFileSync(viteConfigPath, 'utf8');
+    // Check if base property already exists
+    const baseRegex = /base:\s*['"][^'"]*['"],?\s*/;
+    const hasBase = baseRegex.test(configContent);
+    if (hasBase) {
+        // Update existing base property
+        configContent = configContent.replace(baseRegex, `base: '${basePath}',`);
+        console.log(`Updated existing base property in vite.config.ts to '${basePath}'`);
+    }
+    else {
+        // Add base property before server config
+        const serverRegex = /(\s*)(server:\s*\{)/;
+        const serverMatch = configContent.match(serverRegex);
+        if (serverMatch) {
+            const indentation = serverMatch[1] || '  '; // Use existing indentation or default to 2 spaces
+            const replacement = `${indentation}base: '${basePath}',${indentation}${serverMatch[2]}`;
+            configContent = configContent.replace(serverRegex, replacement);
+            console.log(`Added base property to vite.config.ts with value '${basePath}'`);
+        }
+        else {
+            throw new Error('Could not find server config in vite.config.ts to add base property before it');
+        }
+    }
+    fs.writeFileSync(viteConfigPath, configContent, 'utf8');
+}
+/**
+ * Reads the current base value from vite.config.ts.
+ * @param param
+ * @param param.configPath - Path to the vite.config.ts file (defaults to './vite.config.ts')
+ * @returns The current base value or null if not found.
+ */
+export function getCurrentViteBase({ configPath = './vite.config.ts' } = {}) {
+    const viteConfigPath = path.resolve(configPath);
+    if (!fs.existsSync(viteConfigPath)) {
+        return null;
+    }
+    const configContent = fs.readFileSync(viteConfigPath, 'utf8');
+    const baseMatch = configContent.match(/base:\s*['"]([^'"]*)['"]/);
+    return baseMatch ? baseMatch[1] : null;
+}

package/dist/cli/scripts/release/release-config-upload.d.ts

@@ -0,0 +1,7 @@
+import { Config } from './release.js';
+/**
+ * Read and send the rimori configuration to the release endpoint
+ * @param config - Configuration object
+ */
+export declare function sendConfiguration(config: Config): Promise<string>;
+export declare function releasePlugin(config: Config, release_id: string): Promise<void>;

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

@@ -0,0 +1,116 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fs from 'fs';
+import path from 'path';
+import ts from 'typescript';
+/**
+ * Read and send the rimori configuration to the release endpoint
+ * @param config - Configuration object
+ */
+export function sendConfiguration(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const configPath = path.resolve('./rimori/rimori.config.ts');
+        // Check if config file exists
+        try {
+            yield fs.promises.access(configPath);
+        }
+        catch (e) {
+            throw new Error('Could not find rimori.config.ts in ./rimori/ directory');
+        }
+        try {
+            let configObject;
+            // Use TypeScript compiler to transpile and load
+            const configContent = yield fs.promises.readFile(configPath, 'utf8');
+            // Transpile TypeScript to JavaScript
+            const result = ts.transpile(configContent, {
+                target: ts.ScriptTarget.ES2020,
+                module: ts.ModuleKind.ES2020
+            });
+            // Create a temporary file to import the transpiled code
+            const tempFile = path.join(process.cwd(), 'temp_config.js');
+            yield fs.promises.writeFile(tempFile, result);
+            try {
+                // Use dynamic import to load the config
+                const config = yield import(`file://${tempFile}`);
+                configObject = config.default || config;
+                // Clean up temp file
+                yield fs.promises.unlink(tempFile);
+            }
+            catch (error) {
+                // Clean up temp file even on error
+                try {
+                    yield fs.promises.unlink(tempFile);
+                }
+                catch (e) { }
+                throw error;
+            }
+            if (!configObject) {
+                throw new Error('Configuration object is empty or undefined');
+            }
+            console.log(`🚀 Sending configuration...`);
+            const requestBody = {
+                config: configObject,
+                version: config.version,
+                plugin_id: config.plugin_id,
+                release_channel: config.release_channel,
+                rimori_client_version: config.rimori_client_version,
+            };
+            try {
+                const response = yield fetch(`${config.domain}/release`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${config.token}`
+                    },
+                    body: JSON.stringify(requestBody),
+                });
+                const responseText = yield response.text();
+                console.log('Configuration response status:', response.status);
+                console.log('Configuration response text:', responseText);
+                const responseData = JSON.parse(responseText);
+                if (response.ok) {
+                    console.log('✅ Configuration deployed successfully!');
+                    return responseData.release_id;
+                }
+                else {
+                    console.log('❌ Configuration failed!');
+                    console.log('Error:', responseData.error || 'Unknown error');
+                    console.log('Response data:', JSON.stringify(responseData, null, 2));
+                    throw new Error('Configuration upload failed');
+                }
+            }
+            catch (e) {
+                console.log("error", e);
+                throw new Error("Error sending configuration");
+            }
+        }
+        catch (error) {
+            console.error('❌ Error sending configuration:', error.message);
+            throw error;
+        }
+    });
+}
+export function releasePlugin(config, release_id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch(`${config.domain}/release/${release_id}/release`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${config.token}`
+            },
+            body: JSON.stringify({ plugin_id: config.plugin_id })
+        });
+        if (!response.ok) {
+            console.log("Response:", yield response.text());
+            throw new Error("Failed to release plugin");
+        }
+        console.log("✅ Plugin released successfully");
+    });
+}

package/dist/cli/scripts/release/release-db-update.d.ts

@@ -0,0 +1,6 @@
+import { Config } from "./release";
+/**
+ * Read and send the database configuration to the release endpoint
+ * @param config - Configuration object
+ */
+export default function dbUpdate(config: Config, release_id: string): Promise<void>;

package/dist/cli/scripts/release/release-db-update.js

@@ -0,0 +1,100 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fs from 'fs';
+import path from 'path';
+import ts from 'typescript';
+/**
+ * Read and send the database configuration to the release endpoint
+ * @param config - Configuration object
+ */
+export default function dbUpdate(config, release_id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const dbConfigPath = path.resolve('./rimori/db.config.ts');
+        // Check if db config file exists
+        try {
+            yield fs.promises.access(dbConfigPath);
+        }
+        catch (e) {
+            console.warn('Could not find db.config.ts in ./rimori/ directory. Skipping database configuration upload.');
+            return;
+        }
+        try {
+            let dbConfigObject;
+            // Use TypeScript compiler to transpile and load
+            const dbConfigContent = yield fs.promises.readFile(dbConfigPath, 'utf8');
+            // Transpile TypeScript to JavaScript
+            const result = ts.transpile(dbConfigContent, {
+                target: ts.ScriptTarget.ES2020,
+                module: ts.ModuleKind.ES2020
+            });
+            // Create a temporary file to import the transpiled code
+            const tempFile = path.join(process.cwd(), 'temp_db_config.js');
+            yield fs.promises.writeFile(tempFile, result);
+            try {
+                // Use dynamic import to load the db config
+                const dbConfig = yield import(`file://${tempFile}`);
+                dbConfigObject = Object.values(dbConfig);
+                // Clean up temp file
+                yield fs.promises.unlink(tempFile);
+            }
+            catch (error) {
+                // Clean up temp file even on error
+                try {
+                    yield fs.promises.unlink(tempFile);
+                }
+                catch (e) { }
+                throw error;
+            }
+            if (!dbConfigObject) {
+                throw new Error('Database configuration object is empty or undefined');
+            }
+            console.log(`🗄️ Sending database configuration...`);
+            const requestBody = {
+                db_config: dbConfigObject,
+                version: config.version,
+                release_channel: config.release_channel,
+                plugin_id: config.plugin_id,
+            };
+            const response = yield fetch(`${config.domain}/release/${release_id}/db`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${config.token}`
+                },
+                body: JSON.stringify(requestBody),
+            }).catch((e) => {
+                console.log("error", e);
+                throw new Error("Error sending database configuration");
+            });
+            try {
+                const responseText = yield response.text().catch((e) => {
+                    console.log("error", e);
+                    throw new Error("Error sending database configuration");
+                });
+                const responseData = JSON.parse(responseText);
+                if (response.ok) {
+                    console.log('✅ Database configuration deployed successfully!');
+                }
+                else {
+                    console.log("responseData", responseData);
+                    throw new Error(responseData.message);
+                }
+            }
+            catch (e) {
+                console.log("error", e);
+                throw new Error("Error sending database configuration");
+            }
+        }
+        catch (error) {
+            console.error('❌ Error sending database configuration:', error.message);
+            throw error;
+        }
+    });
+}

package/dist/cli/scripts/release/release-file-upload.d.ts

@@ -0,0 +1,6 @@
+import { Config } from './release.js';
+/**
+ * Upload all files from a directory and its subdirectories to the release function
+ * @param config - Configuration object
+ */
+export declare function uploadDirectory(config: Config, release_id: string): Promise<void>;

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

@@ -0,0 +1,136 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fs from 'fs';
+import path from 'path';
+/**
+ * Upload all files from a directory and its subdirectories to the release function
+ * @param config - Configuration object
+ */
+export function uploadDirectory(config, release_id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const relativePath = './dist';
+        console.log(`📁 Preparing to upload files from ${relativePath}...`);
+        // Check if dist directory exists
+        try {
+            yield 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 = yield 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 = {};
+        for (let i = 0; i < files.length; i++) {
+            const filePath = files[i];
+            try {
+                const fileContent = yield 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) {
+                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 = yield 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 = yield 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
+ */
+function getAllFiles(dirPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const files = [];
+        function traverse(currentPath) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const entries = yield fs.promises.readdir(currentPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(currentPath, entry.name);
+                    if (entry.isDirectory()) {
+                        yield traverse(fullPath);
+                    }
+                    else if (entry.isFile()) {
+                        files.push(fullPath);
+                    }
+                }
+            });
+        }
+        yield traverse(dirPath);
+        return files;
+    });
+}
+/**
+ * Get content type based on file extension
+ */
+function getContentType(filePath) {
+    var _a;
+    const ext = (_a = filePath.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    const contentTypes = {
+        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/dist/cli/scripts/release/release.d.ts

@@ -0,0 +1,23 @@
+#!/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';
+declare const config: {
+    version: any;
+    release_channel: string;
+    plugin_id: any;
+    token: string;
+    domain: string;
+    rimori_client_version: any;
+};
+export type Config = typeof config;
+export {};

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

@@ -0,0 +1,70 @@
+#!/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
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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('^', ''),
+};
+/**
+ * Main release process
+ */
+function releaseProcess() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            console.log(`🚀 Releasing ${config.plugin_id} to ${config.release_channel}...`);
+            // First send the configuration
+            const release_id = yield sendConfiguration(config);
+            yield dbUpdate(config, release_id);
+            // Then upload the files
+            yield uploadDirectory(config, release_id);
+            // Then release the plugin
+            yield releasePlugin(config, release_id);
+        }
+        catch (error) {
+            console.log("❌ Error:", error.message);
+            process.exit(1);
+        }
+    });
+}
+releaseProcess();