@qelos/plugins-cli 0.0.10 → 0.0.12

package/commands/pull.mjs

@@ -2,13 +2,13 @@ import pullController from "../controllers/pull.mjs";
 
 export default function pullCommand(program) {
   program
-    .command('pull [type] [path]', 'pull from qelos app. Ability to pull components, blueprints, configurations, and more.',
+    .command('pull [type] [path]', 'pull from qelos app. Ability to pull components, blueprints, configurations, plugins, blocks, and more.',
       (yargs) => {
         return yargs
           .positional('type', {
-            describe: 'Type of the resource to pull. Can be components, blueprints, configurations, or more.',
+            describe: 'Type of the resource to pull. Can be components, blueprints, configurations, plugins, blocks, or all.',
             type: 'string',
-            choices: ['components', 'blueprints', 'configs'],
+            choices: ['components', 'blueprints', 'configs', 'plugins', 'blocks', 'all', '*'],
             required: true
           })
           .positional('path', {

package/commands/push.mjs

@@ -2,13 +2,13 @@ import pushController from "../controllers/push.mjs";
 
 export default function createCommand(program) {
   program
-    .command('push [type] [path]', 'push to qelos app. Ability to push components, blueprints, configurations, and more.',
+    .command('push [type] [path]', 'push to qelos app. Ability to push components, blueprints, configurations, plugins, blocks, and more.',
       (yargs) => {
         return yargs
           .positional('type', {
-            describe: 'Type of the resource to push. Can be components, blueprints, configurations, or more.',
+            describe: 'Type of the resource to push. Can be components, blueprints, configurations, plugins, blocks, or all.',
             type: 'string',
-            choices: ['components', 'blueprints', 'configs'],
+            choices: ['components', 'blueprints', 'configs', 'plugins', 'blocks', 'all', '*'],
             required: true
           })
           .positional('path', {

package/controllers/pull.mjs

@@ -2,6 +2,8 @@ import { initializeSdk } from '../services/sdk.mjs';
 import { pullComponents } from '../services/components.mjs';
 import { pullBlueprints } from '../services/blueprints.mjs';
 import { pullConfigurations } from '../services/configurations.mjs';
+import { pullPlugins } from '../services/plugins.mjs';
+import { pullBlocks } from '../services/blocks.mjs';
 import { logger } from '../services/logger.mjs';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -25,17 +27,48 @@ export default async function pullController({ type, path: targetPath }) {
 
     const sdk = await initializeSdk();
 
+    // Handle "all" or "*" type
+    if (type === 'all' || type === '*') {
+      logger.section(`Pulling all resources to ${targetPath}`);
+      
+      const types = [
+        { name: 'components', fn: pullComponents },
+        { name: 'blueprints', fn: pullBlueprints },
+        { name: 'configs', fn: pullConfigurations },
+        { name: 'plugins', fn: pullPlugins },
+        { name: 'blocks', fn: pullBlocks }
+      ];
+
+      for (const { name, fn } of types) {
+        const typePath = path.join(targetPath, name);
+        logger.section(`Pulling ${name} to ${typePath}`);
+        try {
+          await fn(sdk, typePath);
+          logger.success(`Successfully pulled ${name}`);
+        } catch (error) {
+          logger.error(`Failed to pull ${name}`, error);
+        }
+      }
+
+      logger.success(`Successfully pulled all resources to ${targetPath}`);
+      return;
+    }
+
     logger.section(`Pulling ${type} to ${targetPath}`);
 
     if (type === 'components') {
       await pullComponents(sdk, targetPath);
     } else if (type === 'blueprints') {
       await pullBlueprints(sdk, targetPath);
+    } else if (type === 'plugins') {
+      await pullPlugins(sdk, targetPath);
+    } else if (type === 'blocks') {
+      await pullBlocks(sdk, targetPath);
     } else if (type === 'config' || type === 'configs' || type === 'configuration') {
       await pullConfigurations(sdk, targetPath);
     } else {
       logger.error(`Unknown type: ${type}`);
-      logger.info('Supported types: components, blueprints, config, configs, configuration');
+      logger.info('Supported types: components, blueprints, plugins, blocks, config, configs, configuration, all');
       process.exit(1);
     }
 

package/controllers/push.mjs

@@ -2,38 +2,79 @@ import { initializeSdk } from '../services/sdk.mjs';
 import { pushComponents } from '../services/components.mjs';
 import { pushBlueprints } from '../services/blueprints.mjs';
 import { pushConfigurations } from '../services/configurations.mjs';
+import { pushPlugins } from '../services/plugins.mjs';
+import { pushBlocks } from '../services/blocks.mjs';
 import { logger } from '../services/logger.mjs';
 import fs from 'node:fs';
+import path from 'node:path';
 
-export default async function pushController({ type, path }) {
+export default async function pushController({ type, path: sourcePath }) {
   try {
     // Validate path exists
-    if (!fs.existsSync(path)) {
-      logger.error(`Path does not exist: ${path}`);
+    if (!fs.existsSync(sourcePath)) {
+      logger.error(`Path does not exist: ${sourcePath}`);
       logger.info('Please provide a valid directory path');
       process.exit(1);
     }
 
     // Validate path is a directory
-    if (!fs.statSync(path).isDirectory()) {
-      logger.error(`Path is not a directory: ${path}`);
+    if (!fs.statSync(sourcePath).isDirectory()) {
+      logger.error(`Path is not a directory: ${sourcePath}`);
       logger.info('Please provide a directory path, not a file');
       process.exit(1);
     }
 
     const sdk = await initializeSdk();
 
-    logger.section(`Pushing ${type} from ${path}`);
+    // Handle "all" or "*" type
+    if (type === 'all' || type === '*') {
+      logger.section(`Pushing all resources from ${sourcePath}`);
+      
+      const types = [
+        { name: 'components', fn: pushComponents },
+        { name: 'blueprints', fn: pushBlueprints },
+        { name: 'configs', fn: pushConfigurations },
+        { name: 'plugins', fn: pushPlugins },
+        { name: 'blocks', fn: pushBlocks }
+      ];
+
+      for (const { name, fn } of types) {
+        const typePath = path.join(sourcePath, name);
+        
+        // Skip if directory doesn't exist
+        if (!fs.existsSync(typePath)) {
+          logger.info(`Skipping ${name} (directory not found: ${typePath})`);
+          continue;
+        }
+        
+        logger.section(`Pushing ${name} from ${typePath}`);
+        try {
+          await fn(sdk, typePath);
+          logger.success(`Successfully pushed ${name}`);
+        } catch (error) {
+          logger.error(`Failed to push ${name}`, error);
+        }
+      }
+
+      logger.success(`Successfully pushed all resources from ${sourcePath}`);
+      return;
+    }
+
+    logger.section(`Pushing ${type} from ${sourcePath}`);
 
     if (type === 'components') {
-      await pushComponents(sdk, path);
+      await pushComponents(sdk, sourcePath);
     } else if (type === 'blueprints') {
-      await pushBlueprints(sdk, path);
-    } else if (type === 'config' || type === 'configs' || type === 'configuration') {
-      await pushConfigurations(sdk, path);
+      await pushBlueprints(sdk, sourcePath);
+    } else if (type === 'plugins') {
+      await pushPlugins(sdk, sourcePath);
+    } else if (type === 'blocks') {
+      await pushBlocks(sdk, sourcePath);
+    }  else if (type === 'config' || type === 'configs' || type === 'configuration') {
+      await pushConfigurations(sdk, sourcePath);
     } else {
       logger.error(`Unknown type: ${type}`);
-      logger.info('Supported types: components, blueprints, config, configs, configuration');
+      logger.info('Supported types: components, blueprints, plugins, blocks, config, configs, configuration, all');
       process.exit(1);
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qelos/plugins-cli",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "CLI to manage QELOS plugins",
   "main": "cli.mjs",
   "bin": {

package/services/blocks.mjs

@@ -0,0 +1,166 @@
+import fs from 'node:fs';
+import { join } from 'node:path';
+import { logger } from './logger.mjs';
+
+/**
+ * Convert string to kebab-case
+ */
+function toKebabCase(str) {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/[\s_]+/g, '-')
+    .toLowerCase();
+}
+
+/**
+ * Push blocks from local directory to remote
+ * @param {Object} sdk - Initialized SDK instance
+ * @param {string} path - Path to blocks directory
+ */
+export async function pushBlocks(sdk, path) {
+  const files = fs.readdirSync(path);
+  const blockFiles = files.filter(f => f.endsWith('.html'));
+  
+  if (blockFiles.length === 0) {
+    logger.warning(`No .html files found in ${path}`);
+    return;
+  }
+  
+  logger.info(`Found ${blockFiles.length} block(s) to push`);
+  let blocksJson = {};
+  
+  try {
+    const jsonPath = join(path, 'blocks.json');
+    if (fs.existsSync(jsonPath)) {
+      blocksJson = JSON.parse(fs.readFileSync(jsonPath, 'utf-8'));
+    }
+  } catch (error) {
+    logger.debug('No blocks.json found or invalid format');
+  }
+  
+  const existingBlocks = await sdk.blocks.getList();
+  const updatedBlocksJson = { ...blocksJson };
+  
+  await Promise.all(blockFiles.map(async (file) => {
+    const fileName = file.replace('.html', '');
+    const info = blocksJson[fileName] || {};
+    const content = fs.readFileSync(join(path, file), 'utf-8');
+    
+    logger.step(`Pushing block: ${fileName}`);
+    
+    // First check if we have an _id in blocks.json
+    let blockId = info._id;
+    
+    // If we have an _id, try to update directly
+    if (blockId) {
+      try {
+        await sdk.blocks.update(blockId, {
+          name: info.name || fileName,
+          content,
+          contentType: info.contentType || 'html',
+          description: info.description || 'Block description'
+        });
+        logger.success(`Updated: ${fileName}`);
+        return;
+      } catch (error) {
+        // If update fails, the block might have been deleted, so we'll create a new one
+        logger.debug(`Block ${fileName} not found by _id, will search or create`);
+      }
+    }
+    
+    // Try to find existing block by name
+    const existingBlock = existingBlocks.find(
+      block => toKebabCase(block.name) === fileName
+    );
+    
+    if (existingBlock) {
+      await sdk.blocks.update(existingBlock._id, {
+        name: info.name || existingBlock.name,
+        content,
+        contentType: info.contentType || 'html',
+        description: info.description || existingBlock.description || 'Block description'
+      });
+      updatedBlocksJson[fileName] = {
+        ...info,
+        _id: existingBlock._id
+      };
+      logger.success(`Updated: ${fileName}`);
+    } else {
+      const newBlock = await sdk.blocks.create({
+        name: info.name || fileName,
+        content,
+        contentType: info.contentType || 'html',
+        description: info.description || 'Block description'
+      });
+      updatedBlocksJson[fileName] = {
+        ...info,
+        _id: newBlock._id,
+        name: newBlock.name
+      };
+      logger.success(`Created: ${fileName}`);
+    }
+  }));
+  
+  // Update blocks.json with new _ids
+  fs.writeFileSync(
+    join(path, 'blocks.json'),
+    JSON.stringify(updatedBlocksJson, null, 2)
+  );
+  
+  logger.info(`Pushed ${blockFiles.length} block(s)`);
+}
+
+/**
+ * Pull blocks from remote to local directory
+ * @param {Object} sdk - Initialized SDK instance
+ * @param {string} targetPath - Path to save blocks
+ */
+export async function pullBlocks(sdk, targetPath) {
+  // Create directory if it doesn't exist
+  if (!fs.existsSync(targetPath)) {
+    fs.mkdirSync(targetPath, { recursive: true });
+    logger.info(`Created directory: ${targetPath}`);
+  }
+
+  const blocks = await sdk.blocks.getList();
+  
+  if (blocks.length === 0) {
+    logger.warning('No blocks found to pull');
+    return;
+  }
+  
+  logger.info(`Found ${blocks.length} block(s) to pull`);
+
+  const blocksInformation = await Promise.all(blocks.map(async (block) => {
+    const fileName = toKebabCase(block.name);
+    const filePath = join(targetPath, `${fileName}.html`);
+
+    const blockDetails = await sdk.blocks.getBlock(block._id);
+    
+    fs.writeFileSync(filePath, blockDetails.content, 'utf-8');
+    logger.step(`Pulled: ${block.name}`);
+
+    return {
+      _id: block._id,
+      name: block.name,
+      description: blockDetails.description,
+      contentType: blockDetails.contentType,
+    };
+  }));
+
+  fs.writeFileSync(
+    join(targetPath, 'blocks.json'),
+    JSON.stringify(
+      blocksInformation.reduce((obj, current) => {
+        const fileName = toKebabCase(current.name);
+        obj[fileName] = current;
+        return obj;
+      }, {}),
+      null,
+      2
+    )
+  );
+
+  logger.info(`Saved blocks.json with metadata`);
+  logger.info(`Pulled ${blocks.length} block(s)`);
+}

package/services/micro-frontends.mjs

@@ -0,0 +1,129 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from './logger.mjs';
+
+/**
+ * Convert a string to kebab-case
+ * @param {string} str - String to convert
+ * @returns {string} Kebab-cased string
+ */
+function toKebabCase(str) {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/[\s_]+/g, '-')
+    .toLowerCase();
+}
+
+/**
+ * Extract micro-frontend structures to separate HTML files
+ * @param {Array} microFrontends - Array of micro-frontend objects
+ * @param {string} pluginPath - Base path for the plugin directory
+ * @returns {Array} Updated micro-frontends with $ref instead of structure
+ */
+export function extractMicroFrontendStructures(microFrontends, pluginPath) {
+  if (!microFrontends || microFrontends.length === 0) {
+    return microFrontends;
+  }
+
+  const microFrontendsDir = path.join(pluginPath, 'micro-frontends');
+  
+  // Create micro-frontends directory if it doesn't exist
+  if (!fs.existsSync(microFrontendsDir)) {
+    fs.mkdirSync(microFrontendsDir, { recursive: true });
+  }
+
+  return microFrontends.map((mf) => {
+    // Skip if no structure or structure is already a reference
+    if (!mf.structure || typeof mf.structure === 'object') {
+      return mf;
+    }
+
+    // Generate filename from route name or micro-frontend name
+    const fileName = mf.route?.name 
+      ? toKebabCase(mf.route.name) 
+      : toKebabCase(mf.name);
+    
+    const htmlFileName = `${fileName}.html`;
+    const htmlFilePath = path.join(microFrontendsDir, htmlFileName);
+    const relativeRef = `./micro-frontends/${htmlFileName}`;
+
+    // Write structure to HTML file
+    fs.writeFileSync(htmlFilePath, mf.structure, 'utf-8');
+    logger.debug(`Extracted structure to: ${relativeRef}`);
+
+    // Return micro-frontend with $ref instead of structure
+    return {
+      ...mf,
+      structure: { $ref: relativeRef }
+    };
+  });
+}
+
+/**
+ * Load content from a $ref reference
+ * @param {string} ref - Reference path (relative, absolute, or URL)
+ * @param {string} basePath - Base path for resolving relative references
+ * @returns {Promise<string>} Loaded content
+ */
+async function loadReference(ref, basePath) {
+  // Handle HTTP/HTTPS URLs
+  if (ref.startsWith('http://') || ref.startsWith('https://')) {
+    logger.debug(`Loading structure from URL: ${ref}`);
+    try {
+      const response = await fetch(ref);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return await response.text();
+    } catch (error) {
+      throw new Error(`Failed to load from URL ${ref}: ${error.message}`);
+    }
+  }
+
+  // Handle absolute and relative paths
+  const filePath = path.isAbsolute(ref) 
+    ? ref 
+    : path.resolve(basePath, ref);
+
+  logger.debug(`Loading structure from file: ${filePath}`);
+  
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Referenced file does not exist: ${filePath}`);
+  }
+
+  return fs.readFileSync(filePath, 'utf-8');
+}
+
+/**
+ * Resolve micro-frontend structures from $ref references
+ * @param {Array} microFrontends - Array of micro-frontend objects
+ * @param {string} pluginPath - Base path for resolving relative references
+ * @returns {Promise<Array>} Updated micro-frontends with resolved structures
+ */
+export async function resolveMicroFrontendStructures(microFrontends, pluginPath) {
+  if (!microFrontends || microFrontends.length === 0) {
+    return microFrontends;
+  }
+
+  return await Promise.all(microFrontends.map(async (mf) => {
+    // Skip if no structure or structure is not a reference object
+    if (!mf.structure || typeof mf.structure !== 'object' || !mf.structure.$ref) {
+      return mf;
+    }
+
+    const ref = mf.structure.$ref;
+    
+    try {
+      const content = await loadReference(ref, pluginPath);
+      
+      // Return micro-frontend with resolved structure
+      return {
+        ...mf,
+        structure: content
+      };
+    } catch (error) {
+      logger.error(`Failed to resolve $ref for ${mf.name}: ${error.message}`);
+      throw error;
+    }
+  }));
+}

package/services/plugins.mjs

@@ -0,0 +1,181 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { join } from 'node:path';
+import { logger } from './logger.mjs';
+import { extractMicroFrontendStructures, resolveMicroFrontendStructures } from './micro-frontends.mjs';
+
+/**
+ * Push plugins from local directory to remote
+ * @param {Object} sdk - Initialized SDK instance
+ * @param {string} path - Path to plugins directory
+ */
+export async function pushPlugins(sdk, path) {
+  const files = fs.readdirSync(path);
+  const pluginFiles = files.filter(f => f.endsWith('.plugin.json'));
+  
+  if (pluginFiles.length === 0) {
+    logger.warning(`No plugin files (*.plugin.json) found in ${path}`);
+    return;
+  }
+  
+  logger.info(`Found ${pluginFiles.length} plugin(s) to push`);
+  const existingPlugins = await sdk.managePlugins.getList();
+  
+  const results = await Promise.allSettled(pluginFiles.map(async (file) => {
+    if (file.endsWith('.plugin.json')) {
+      let pluginData;
+      try {
+        pluginData = JSON.parse(fs.readFileSync(join(path, file), 'utf-8'));
+      } catch (error) {
+        logger.error(`Failed to parse ${file}`, error);
+        throw new Error(`Parse error in ${file}: ${error.message}`);
+      }
+      
+      const apiPath = pluginData.apiPath;
+      
+      if (!apiPath) {
+        logger.warning(`Skipping ${file}: missing apiPath field`);
+        return { skipped: true, file };
+      }
+      
+      logger.step(`Pushing plugin: ${apiPath}`);
+      
+      // Resolve micro-frontend structures from $ref references
+      if (pluginData.microFrontends && pluginData.microFrontends.length > 0) {
+        try {
+          pluginData.microFrontends = await resolveMicroFrontendStructures(
+            pluginData.microFrontends,
+            path
+          );
+        } catch (error) {
+          logger.error(`Failed to resolve micro-frontend structures for ${apiPath}`, error);
+          throw new Error(`Failed to resolve structures for ${apiPath}: ${error.message}`);
+        }
+      }
+      
+      const existingPlugin = existingPlugins.find(
+        plugin => plugin.apiPath === apiPath
+      );
+      
+      try {
+        if (existingPlugin) {
+          await sdk.managePlugins.update(existingPlugin._id, pluginData);
+          logger.success(`Updated: ${apiPath}`);
+        } else {
+          await sdk.managePlugins.create(pluginData);
+          logger.success(`Created: ${apiPath}`);
+        }
+        return { success: true, apiPath };
+      } catch (error) {
+        // Extract detailed error information
+        let errorMessage = error.message || 'Unknown error';
+        let errorDetails = null;
+        
+        // The SDK throws the response body as the error
+        if (typeof error === 'object' && error !== null) {
+          if (error.message) {
+            errorMessage = error.message;
+          }
+          if (error.error) {
+            errorDetails = error.error;
+          }
+          if (error.errors) {
+            errorDetails = error.errors;
+          }
+        }
+        
+        logger.error(`Failed to push ${apiPath}: ${errorMessage}`);
+        
+        if (errorDetails) {
+          if (typeof errorDetails === 'string') {
+            logger.error(`  Details: ${errorDetails}`);
+          } else {
+            logger.error(`  Details: ${JSON.stringify(errorDetails, null, 2)}`);
+          }
+        }
+        
+        if (process.env.VERBOSE && error.stack) {
+          logger.debug(`Stack: ${error.stack}`);
+        }
+        
+        throw new Error(`Failed to push ${apiPath}: ${errorMessage}`);
+      }
+    }
+  }));
+  
+  // Check for failures
+  const failures = results.filter(r => r.status === 'rejected');
+  
+  if (failures.length > 0) {
+    logger.error(`\n${failures.length} plugin(s) failed to push:`);
+    failures.forEach(f => {
+      logger.error(`  • ${f.reason.message}`);
+    });
+    throw new Error(`Failed to push ${failures.length} plugin(s)`);
+  }
+  
+  logger.info(`Pushed ${pluginFiles.length} plugin(s)`);
+}
+
+/**
+ * Pull plugins from remote to local directory
+ * @param {Object} sdk - Initialized SDK instance
+ * @param {string} targetPath - Path to save plugins
+ */
+export async function pullPlugins(sdk, targetPath) {
+  // Create directory if it doesn't exist
+  if (!fs.existsSync(targetPath)) {
+    fs.mkdirSync(targetPath, { recursive: true });
+    logger.info(`Created directory: ${targetPath}`);
+  }
+
+  const plugins = await sdk.managePlugins.getList();
+  
+  if (plugins.length === 0) {
+    logger.warning('No plugins found to pull');
+    return;
+  }
+  
+  logger.info(`Found ${plugins.length} plugin(s) to pull`);
+
+  await Promise.all(plugins.map(async (plugin) => {
+    const fileName = `${plugin.apiPath}.plugin.json`;
+    const filePath = join(targetPath, fileName);
+    const pluginDir = join(targetPath, plugin.apiPath);
+
+    // Fetch full plugin details
+    const fullPlugin = await sdk.managePlugins.getById(plugin._id);
+
+    function removeIdFromObject(obj) {
+      const { _id, ...rest } = obj;
+      return rest;
+    }
+
+    // Extract micro-frontend structures to separate files
+    const processedMicroFrontends = extractMicroFrontendStructures(
+      (fullPlugin.microFrontends || []).map(removeIdFromObject),
+      targetPath
+    );
+
+    const relevantFields = {
+      name: fullPlugin.name,
+      description: fullPlugin.description,
+      manifestUrl: fullPlugin.manifestUrl,
+      callbackUrl: fullPlugin.callbackUrl,
+      registerUrl: fullPlugin.registerUrl,
+      apiPath: fullPlugin.apiPath,
+      authAcquire: fullPlugin.authAcquire,
+      proxyUrl: fullPlugin.proxyUrl,
+      subscribedEvents: (fullPlugin.subscribedEvents || []).map(removeIdFromObject),
+      microFrontends: processedMicroFrontends,
+      injectables: (fullPlugin.injectables || []).map(removeIdFromObject),
+      navBarGroups: (fullPlugin.navBarGroups || []).map(removeIdFromObject),
+      cruds: (fullPlugin.cruds || []).map(removeIdFromObject),
+    }
+    
+    fs.writeFileSync(filePath, JSON.stringify(relevantFields, null, 2), 'utf-8');
+    logger.step(`Pulled: ${plugin.apiPath}`);
+  }));
+
+  logger.info(`Pulled ${plugins.length} plugin(s)`);
+}