@qelos/plugins-cli 0.0.23 → 0.0.25

package/package.json

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

package/services/blueprints.mjs

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { join } from 'node:path';
 import { logger } from './logger.mjs';
+import { removeIdFromObject } from '../utils/object-utils.mjs';
 
 /**
  * Push blueprints from local directory to remote
@@ -137,11 +138,6 @@ export async function pullBlueprints(sdk, targetPath) {
     // Fetch full blueprint details
     const fullBlueprint = await sdk.manageBlueprints.getBlueprint(blueprint.identifier);
 
-    function removeIdFromObject(obj) {
-      const { _id, ...rest } = obj;
-      return rest;
-    }
-
     const relevantFields = {
       identifier: fullBlueprint.identifier,
       name: fullBlueprint.name,

package/services/components.mjs

@@ -1,23 +1,57 @@
 import fs from 'node:fs';
-import { join } from 'node:path';
+import path, { join } from 'node:path';
 import { logger } from './logger.mjs';
 
+function normalizeRelativeIdentifier(value) {
+  return String(value || '')
+    .replaceAll('\\', '/')
+    .replace(/^\//, '')
+    .trim();
+}
+
+function isSafeRelativeIdentifier(value) {
+  if (!value) return false;
+  if (value.includes('..')) return false;
+  if (value.startsWith('/')) return false;
+  return true;
+}
+
+function listVueFilesRecursively(rootDir, currentDir = rootDir, out = []) {
+  const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === 'node_modules' || entry.name === '.git') continue;
+      listVueFilesRecursively(rootDir, fullPath, out);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (!entry.name.endsWith('.vue')) continue;
+    if (entry.name === 'components.json') continue;
+    out.push(fullPath);
+  }
+  return out;
+}
+
 /**
  * Push components from local directory to remote
  * @param {Object} sdk - Initialized SDK instance
  * @param {string} path - Path to components directory
  */
-export async function pushComponents(sdk, path, options = {}) {
+export async function pushComponents(sdk, componentsPath, options = {}) {
   const { targetFile } = options;
-  const directoryFiles = fs.readdirSync(path);
-  const files = targetFile ? [targetFile] : directoryFiles;
-  const vueFiles = files.filter(f => f.endsWith('.vue'));
+  const vueFilePaths = targetFile
+    ? [join(componentsPath, targetFile)]
+    : listVueFilesRecursively(componentsPath);
+  const vueFiles = vueFilePaths
+    .filter(filePath => fs.existsSync(filePath))
+    .filter(filePath => filePath.endsWith('.vue'));
   
   if (vueFiles.length === 0) {
     if (targetFile) {
       logger.warning(`File ${targetFile} is not a .vue component. Skipping.`);
     } else {
-      logger.warning(`No .vue files found in ${path}`);
+      logger.warning(`No .vue files found in ${componentsPath}`);
     }
     return;
   }
@@ -26,7 +60,7 @@ export async function pushComponents(sdk, path, options = {}) {
   let componentsJson = {};
   
   try {
-    const jsonPath = join(path, 'components.json');
+    const jsonPath = join(componentsPath, 'components.json');
     if (fs.existsSync(jsonPath)) {
       componentsJson = JSON.parse(fs.readFileSync(jsonPath));
     }
@@ -38,11 +72,17 @@ export async function pushComponents(sdk, path, options = {}) {
   
   await Promise.all(vueFiles.map(async (file) => {
     if (file.endsWith('.vue')) {
-      const componentName = file.replace('.vue', '');
+      const relativePath = normalizeRelativeIdentifier(path.relative(componentsPath, file));
+      const componentName = relativePath.split('/').pop().replace('.vue', '');
       const info = componentsJson[componentName] || {};
-      const content = fs.readFileSync(join(path, file), 'utf-8');
-      const targetIdentifier = info.identifier || componentName;
+      const content = fs.readFileSync(file, 'utf-8');
+      const targetIdentifier = normalizeRelativeIdentifier(info.identifier || relativePath.replace('.vue', ''));
       const targetDescription = info.description || 'Component description';
+
+      if (!isSafeRelativeIdentifier(targetIdentifier)) {
+        logger.error(`Skipping component with unsafe identifier: ${targetIdentifier}`);
+        return;
+      }
       
       logger.step(`Pushing component: ${componentName}`);
       
@@ -102,9 +142,20 @@ export async function pullComponents(sdk, targetPath) {
   logger.info(`Found ${components.length} component(s) to pull`);
 
   const componentsInformation = await Promise.all(components.map(async (component) => {
-    const fileName = `${component.componentName}.vue`;
+    const normalizedIdentifier = normalizeRelativeIdentifier(component.identifier);
+    const fileName = `${normalizedIdentifier}.vue`;
     const filePath = join(targetPath, fileName);
 
+    if (!isSafeRelativeIdentifier(normalizedIdentifier)) {
+      logger.error(`Skipping pull for unsafe identifier: ${component.identifier}`);
+      return null;
+    }
+
+    const targetDir = join(targetPath, fileName.split('/').slice(0, -1).join('/'));
+    if (targetDir && !fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+
     const { content, description } = await sdk.components.getComponent(component._id);
     
     fs.writeFileSync(filePath, content, 'utf-8');
@@ -118,10 +169,12 @@ export async function pullComponents(sdk, targetPath) {
     };
   }));
 
+  const filteredComponentsInformation = componentsInformation.filter(Boolean);
+
   fs.writeFileSync(
     join(targetPath, 'components.json'),
     JSON.stringify(
-      componentsInformation.reduce((obj, current) => {
+      filteredComponentsInformation.reduce((obj, current) => {
         obj[current.componentName] = current;
         return obj;
       }, {}),
@@ -131,5 +184,5 @@ export async function pullComponents(sdk, targetPath) {
   );
 
   logger.info(`Saved components.json with metadata`);
-  logger.info(`Pulled ${components.length} component(s)`);
+  logger.info(`Pulled ${filteredComponentsInformation.length} component(s)`);
 }

package/services/git-files.mjs

@@ -3,6 +3,61 @@ import { logger } from './logger.mjs';
 import path from 'node:path';
 import fs from 'node:fs';
 
+/**
+ * Resolve the actual file path from Git output
+ * Git might show temp paths or different formats, so we need to find the real file
+ * @param {string} gitPath - Path as reported by Git
+ * @param {string} basePath - Base path to search for the actual file
+ * @returns {string|null} The actual file path or null if not found
+ */
+function resolveActualFilePath(gitPath, basePath) {
+  // First try the direct path
+  const directPath = path.resolve(basePath, gitPath);
+  if (fs.existsSync(directPath)) {
+    return directPath;
+  }
+  
+  // If it's an HTML file, it might be in a micro-frontends directory
+  if (gitPath.endsWith('.html')) {
+    // Try to find it in any plugin's micro-frontends directory
+    const pluginsDir = path.join(basePath, 'plugins');
+    if (fs.existsSync(pluginsDir)) {
+      const plugins = fs.readdirSync(pluginsDir);
+      const filename = path.basename(gitPath);
+      
+      for (const plugin of plugins) {
+        const mfPath = path.join(pluginsDir, plugin, 'micro-frontends', filename);
+        if (fs.existsSync(mfPath)) {
+          return mfPath;
+        }
+      }
+    }
+  }
+  
+  // For other files, try searching in common directories
+  const filename = path.basename(gitPath);
+  const searchDirs = [
+    'components',
+    'blueprints', 
+    'configs',
+    'plugins',
+    'blocks',
+    'integrations',
+    'connections',
+    'prompts'
+  ];
+  
+  for (const dir of searchDirs) {
+    const searchPath = path.join(basePath, dir, filename);
+    if (fs.existsSync(searchPath)) {
+      return searchPath;
+    }
+  }
+  
+  // If still not found, return null
+  return null;
+}
+
 /**
  * Get the list of files committed in the last commit
  * @returns {string[]} Array of file paths
@@ -114,8 +169,22 @@ function classifyFiles(files, basePath) {
   };
 
   for (const file of files) {
+    // Try to resolve the actual file path (handles Git temp paths)
+    let fullPath = path.resolve(basePath, file);
+    
+    // If the direct path doesn't exist, try to find the actual file
+    if (!fs.existsSync(fullPath)) {
+      const resolvedPath = resolveActualFilePath(file, basePath);
+      if (resolvedPath) {
+        logger.debug(`Resolved Git path ${file} to actual path ${resolvedPath}`);
+        fullPath = resolvedPath;
+      } else {
+        logger.warning(`File not found, skipping: ${file}`);
+        continue;
+      }
+    }
+    
     // Make sure the file exists
-    const fullPath = path.resolve(basePath, file);
     if (!fs.existsSync(fullPath)) {
       logger.warning(`File not found, skipping: ${file}`);
       continue;
@@ -164,8 +233,33 @@ function classifyFiles(files, basePath) {
       
       // For HTML files, we need to find which plugin contains them
       // HTML files in plugins are typically part of the plugin structure
-      const pluginDir = path.dirname(fullPath);
-      const pluginJson = path.join(pluginDir, 'plugin.json');
+      let pluginDir = path.dirname(fullPath);
+      let pluginJson = path.join(pluginDir, 'plugin.json');
+      
+      // If the file is in a temp path or unusual location, try to find the actual plugin
+      if (!fs.existsSync(pluginJson)) {
+        // Check if we're in a micro-frontends subdirectory
+        if (path.basename(pluginDir) === 'micro-frontends' || 
+            relativePath.includes('micro-frontends/') ||
+            relativePath.includes('micro-frontends\\')) {
+          // Go up one more level to find the plugin directory
+          pluginDir = path.dirname(pluginDir);
+          pluginJson = path.join(pluginDir, 'plugin.json');
+        }
+        
+        // If still not found, try searching for plugin.json in parent directories
+        if (!fs.existsSync(pluginJson)) {
+          let searchDir = pluginDir;
+          for (let i = 0; i < 3; i++) { // Search up to 3 levels up
+            searchDir = path.dirname(searchDir);
+            const testPluginJson = path.join(searchDir, 'plugin.json');
+            if (fs.existsSync(testPluginJson)) {
+              pluginJson = testPluginJson;
+              break;
+            }
+          }
+        }
+      }
       
       if (fs.existsSync(pluginJson)) {
         // This HTML file is part of a plugin
@@ -173,6 +267,8 @@ function classifyFiles(files, basePath) {
           classified.plugins.push(pluginJson);
           logger.debug(`Found plugin containing HTML ${relativePath}: ${path.basename(pluginJson)}`);
         }
+      } else {
+        logger.warning(`Could not find plugin.json for HTML file: ${relativePath}`);
       }
     } else {
       logger.debug(`Unclassified file: ${relativePath}`);

package/services/micro-frontends.mjs

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { logger } from './logger.mjs';
 import { loadReference } from './file-refs.mjs';
+import { removeIdFromObject } from '../utils/object-utils.mjs';
 
 /**
  * Convert a string to kebab-case
@@ -55,6 +56,7 @@ export function extractMicroFrontendStructures(microFrontends, pluginPath) {
     // Return micro-frontend with $ref instead of structure
     return {
       ...mf,
+      requirements: (mf.requirements || []).map(removeIdFromObject),
       structure: { $ref: relativeRef }
     };
   });

package/services/plugins.mjs

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { join } from 'node:path';
 import { logger } from './logger.mjs';
 import { extractMicroFrontendStructures, resolveMicroFrontendStructures } from './micro-frontends.mjs';
+import { removeIdFromObject } from '../utils/object-utils.mjs';
 
 function sanitizePluginForFile(plugin) {
   const sanitized = JSON.parse(JSON.stringify(plugin));
@@ -194,11 +195,6 @@ export async function pullPlugins(sdk, targetPath) {
     // 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),

package/utils/object-utils.mjs

@@ -0,0 +1,9 @@
+/**
+ * Removes the _id property from an object
+ * @param {Object} obj - The object to remove _id from
+ * @returns {Object} - The object without _id
+ */
+export function removeIdFromObject(obj) {
+  const { _id, ...rest } = obj;
+  return rest;
+}