@qelos/plugins-cli 0.0.30 → 0.1.1

package/cli.mjs

@@ -11,6 +11,7 @@ import pushCommand from './commands/push.mjs';
 import pullCommand from './commands/pull.mjs';
 import generateCommand from './commands/generate.mjs';
 import blueprintsCommand from './commands/blueprints.mjs';
+import getCommand from './commands/get.mjs';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 const program = yargs(hideBin(process.argv));
@@ -28,5 +29,6 @@ pushCommand(program)
 pullCommand(program)
 generateCommand(program)
 blueprintsCommand(program)
+getCommand(program)
 
 program.help().argv;

package/commands/get.mjs

@@ -0,0 +1,26 @@
+import getController from "../controllers/get.mjs";
+
+export default function getCommand(program) {
+  program
+    .command('get [type] [path]', 'get files from git without pushing. Ability to view components, blueprints, configurations, plugins, blocks, committed files, or staged files.',
+      (yargs) => {
+        return yargs
+          .positional('type', {
+            describe: 'Type of the resource to get. Can be components, blueprints, configurations, plugins, blocks, integrations, connections, committed, staged, or all.',
+            type: 'string',
+            choices: ['components', 'blueprints', 'configs', 'plugins', 'blocks', 'integrations', 'connections', 'committed', 'staged', 'all', '*'],
+            required: true
+          })
+          .positional('path', {
+            describe: 'Path to search for resources.',
+            type: 'string',
+            required: true
+          })
+          .option('json', {
+            alias: 'j',
+            type: 'boolean',
+            description: 'Output in JSON format'
+          })
+      },
+      getController)
+}

package/commands/push.mjs

@@ -16,6 +16,12 @@ export default function pushCommand(program) {
             type: 'string',
             required: true
           })
+          .option('hard', {
+            alias: 'h',
+            type: 'boolean',
+            describe: 'Hard push: remove resources from Qelos that don\'t exist locally (only for components, integrations, plugins, blueprints when pushing a directory)',
+            default: false
+          })
       },
       pushController)
 }

package/controllers/create.mjs

@@ -1,5 +1,5 @@
 import follow from "follow-redirects";
-import cliSelect from "cli-select";
+import { interactiveSelect } from "../services/interactive-select.mjs";
 import { blue } from "../utils/colors.mjs";
 import DecompressZip from "decompress-zip";
 import { join } from "node:path";
@@ -53,7 +53,7 @@ export default async function createController({ name, boilerplate }) {
   } else {
     console.log(blue("Choose a boilerplate:"));
     try {
-      const project = await cliSelect({
+      const project = await interactiveSelect({
         values: {
           vanilla: "Vanilla",
           vue: "Vue",
@@ -62,12 +62,14 @@ export default async function createController({ name, boilerplate }) {
           more: "Show more",
           custom: "Custom from Github",
         },
+        message: "Choose a boilerplate:"
       });
       repository = project.id;
 
       if (repository === "more") {
-        const selected = await cliSelect({
+        const selected = await interactiveSelect({
           values: await getOrgReposNames(organization),
+          message: "Choose a repository:"
         });
         repository = selected.id;
       } else if (repository === "custom") {

package/controllers/get.mjs

@@ -0,0 +1,54 @@
+import { logger } from '../services/logger.mjs';
+import { getGitFiles } from '../services/git-files.mjs';
+import { green, blue, yellow, red } from '../utils/colors.mjs';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export default async function getController(argv) {
+  const { type, path: basePath, json, verbose } = argv;
+  
+  if (verbose) {
+    process.env.VERBOSE = 'true';
+  }
+  
+  try {
+    // For git-based types (committed, staged)
+    if (type === 'committed' || type === 'staged') {
+      const classified = getGitFiles(type, basePath || '.');
+      
+      if (json) {
+        console.log(JSON.stringify(classified, null, 2));
+        return;
+      }
+      
+      // Display results
+      console.log(blue(`\n=== ${type.toUpperCase()} FILES ===\n`));
+      
+      Object.entries(classified).forEach(([fileType, files]) => {
+        if (files.length > 0) {
+          console.log(yellow(`${fileType.toUpperCase()} (${files.length}):`));
+          files.forEach(file => {
+            const relativePath = path.relative(basePath || '.', file);
+            console.log(`  - ${relativePath}`);
+          });
+          console.log('');
+        }
+      });
+      
+      return;
+    }
+    
+    // For other types, we would need to implement similar logic to push
+    // For now, just show what would be searched for
+    console.log(blue(`\n=== SEARCH FOR ${type.toUpperCase()} ===\n`));
+    console.log(yellow(`Base path: ${basePath || '.'}`));
+    console.log(red(`Note: Only 'committed' and 'staged' types are currently supported for preview.`));
+    
+  } catch (error) {
+    logger.error(error.message);
+    if (verbose) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}

package/controllers/pull.mjs

@@ -39,8 +39,8 @@ export default async function pullController({ type, path: targetPath = './' })
         { name: 'configs', fn: pullConfigurations },
         { name: 'plugins', fn: pullPlugins },
         { name: 'blocks', fn: pullBlocks },
+        { name: 'connections', fn: pullConnections },
         { name: 'integrations', fn: pullIntegrations },
-        { name: 'connections', fn: pullConnections }
       ];
 
       for (const { name, fn } of types) {

package/controllers/push.mjs

@@ -7,15 +7,26 @@ import { pushBlocks } from '../services/blocks.mjs';
 import { pushIntegrations } from '../services/integrations.mjs';
 import { pushConnections } from '../services/connections.mjs';
 import { getGitFiles, prepareTempDirectories } from '../services/git-files.mjs';
+import { checkDuplicateIdentifiers, displayDuplicateConflicts } from '../services/duplicate-checker.mjs';
 import { logger } from '../services/logger.mjs';
+import { getLocalFiles, getRemoteResources, getIdentifierFromFile, confirmHardPush, removeResources } from '../services/hard-push.mjs';
 import fs from 'node:fs';
 import path from 'node:path';
 import { mkdtemp } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 
-export default async function pushController({ type, path: sourcePath }) {
+export default async function pushController({ type, path: sourcePath, hard = false }) {
   let tempDir = null;
   
+  // Validate hard flag usage
+  if (hard) {
+    const validTypes = ['components', 'blueprints', 'plugins', 'integrations', 'all', '*'];
+    if (!validTypes.includes(type)) {
+      logger.error('--hard flag is only available for: components, blueprints, plugins, integrations, or all');
+      process.exit(1);
+    }
+  }
+  
   try {
     // Handle git-based types (committed and staged)
     if (type === 'committed' || type === 'staged') {
@@ -66,6 +77,15 @@ export default async function pushController({ type, path: sourcePath }) {
       for (const { name, fn } of types) {
         if (!tempPaths[name]) continue;
         
+        // Check for duplicate identifiers (skip components and blocks as they can't have duplicates)
+        if (name !== 'components' && name !== 'blocks') {
+          const duplicates = checkDuplicateIdentifiers(classifiedFiles[name], name, tempPaths[name]);
+          if (duplicates.length > 0) {
+            displayDuplicateConflicts(duplicates, name);
+            process.exit(1);
+          }
+        }
+        
         logger.section(`Pushing ${name} (${classifiedFiles[name].length} file(s))`);
         
         // Show the actual files being pushed
@@ -110,12 +130,79 @@ export default async function pushController({ type, path: sourcePath }) {
       basePath = path.dirname(sourcePath);
       targetFile = path.basename(sourcePath);
       logger.info(`Detected file path. Only pushing ${targetFile}`);
+      
+      // Prevent using hard flag with single files
+      if (hard) {
+        logger.error('--hard flag can only be used when pushing a directory, not a single file');
+        process.exit(1);
+      }
     } else if (!stat.isDirectory()) {
       logger.error(`Path must be a file or directory: ${sourcePath}`);
       process.exit(1);
     }
 
-    const sdk = await initializeSdk();
+    // Check for duplicate identifiers when pushing a directory
+    if (!targetFile && type !== 'components' && type !== 'blocks') {
+      // basePath is already the directory path when pushing a directory
+      const typePath = basePath;
+      if (fs.existsSync(typePath)) {
+        let resourceFiles = [];
+        
+        // For other types, just look at the top level
+        const files = fs.readdirSync(typePath);
+        resourceFiles = files.filter(file => {
+          if (type === 'blueprints') return file.endsWith('.blueprint.json');
+          if (type === 'configs') return file.endsWith('.config.json');
+          if (type === 'plugins') return file.endsWith('.plugin.json');
+          if (type === 'integrations' || type === 'integration') return file.endsWith('.integration.json');
+          if (type === 'connections' || type === 'connection') return file.endsWith('.connection.json');
+          return false;
+        });
+        
+        const filePaths = resourceFiles.map(file => path.join(typePath, file));
+        const duplicates = checkDuplicateIdentifiers(filePaths, type, typePath);
+        if (duplicates.length > 0) {
+          displayDuplicateConflicts(duplicates, type);
+          process.exit(1);
+        }
+      }
+    }
+
+    // Handle hard push logic for individual types (only when pushing directories)
+    if (hard && !targetFile && ['components', 'blueprints', 'plugins', 'integrations'].includes(type)) {
+      logger.info('Checking for resources to remove...');
+      
+      const sdk = await initializeSdk();
+      const typePath = basePath;
+      
+      // Get local files
+      const localFiles = getLocalFiles(typePath, type);
+      const localIdentifiers = localFiles.map(file => getIdentifierFromFile(file, type));
+      
+      // Get remote resources
+      const remoteResources = await getRemoteResources(sdk, type);
+      const remoteIdentifiers = remoteResources.map(r => r.identifier);
+      
+      // Find resources to remove (exist remotely but not locally)
+      const toRemove = remoteIdentifiers
+        .filter(id => !localIdentifiers.includes(id))
+        .map(identifier => ({ type, identifier }));
+      
+      if (toRemove.length > 0) {
+        const confirmed = await confirmHardPush(toRemove);
+        if (!confirmed) {
+          logger.info('Operation cancelled by user.');
+          process.exit(0);
+        }
+        
+        // Store the removal list for later (after push)
+        // We'll use an environment variable to pass it to the post-push cleanup
+        process.env.QELOS_HARD_PUSH_REMOVE = JSON.stringify(toRemove);
+        logger.info(`Will remove ${toRemove.length} ${type} after push completes`);
+      } else {
+        logger.info('No resources to remove');
+      }
+    }
 
     // Handle "all" or "*" type
     if (type === 'all' || type === '*') {
@@ -144,6 +231,86 @@ export default async function pushController({ type, path: sourcePath }) {
           continue;
         }
         
+        // Get all files in the directory
+        const files = fs.readdirSync(typePath);
+        const resourceFiles = files.filter(file => {
+          if (name === 'components') return file.endsWith('.vue');
+          if (name === 'blocks') return file.endsWith('.html');
+          if (name === 'blueprints') return file.endsWith('.blueprint.json');
+          if (name === 'configs') return file.endsWith('.config.json');
+          if (name === 'plugins') return file.endsWith('.plugin.json');
+          if (name === 'integrations') return file.endsWith('.integration.json');
+          if (name === 'connections') return file.endsWith('.connection.json');
+          return false;
+        });
+        
+        // Check for duplicate identifiers (skip components and blocks as they can't have duplicates)
+        if (name !== 'components' && name !== 'blocks') {
+          const filePaths = resourceFiles.map(file => path.join(typePath, file));
+          const duplicates = checkDuplicateIdentifiers(filePaths, name, typePath);
+          if (duplicates.length > 0) {
+            displayDuplicateConflicts(duplicates, name);
+            process.exit(1);
+          }
+        }
+      }
+      
+      // Initialize SDK only after duplicate checks pass
+      const sdk = await initializeSdk();
+      
+      // Handle hard push logic for "all" type
+      if (hard) {
+        logger.info('Checking for resources to remove...');
+        
+        const toRemoveAll = [];
+        
+        // Check each type
+        for (const { name } of types) {
+          if (!['components', 'blueprints', 'plugins', 'integrations'].includes(name)) continue;
+          
+          const typePath = path.join(basePath, name);
+          if (!fs.existsSync(typePath)) continue;
+          
+          // Get local files
+          const localFiles = getLocalFiles(typePath, name);
+          const localIdentifiers = localFiles.map(file => getIdentifierFromFile(file, name));
+          
+          // Get remote resources
+          const remoteResources = await getRemoteResources(sdk, name);
+          const remoteIdentifiers = remoteResources.map(r => r.identifier);
+          
+          // Find resources to remove
+          const toRemove = remoteIdentifiers
+            .filter(id => !localIdentifiers.includes(id))
+            .map(identifier => ({ type: name, identifier }));
+          
+          toRemoveAll.push(...toRemove);
+        }
+        
+        if (toRemoveAll.length > 0) {
+          const confirmed = await confirmHardPush(toRemoveAll);
+          if (!confirmed) {
+            logger.info('Operation cancelled by user.');
+            process.exit(0);
+          }
+          
+          // Store the removal list for later (after push)
+          process.env.QELOS_HARD_PUSH_REMOVE = JSON.stringify(toRemoveAll);
+          logger.info(`Will remove ${toRemoveAll.length} resources after push completes`);
+        } else {
+          logger.info('No resources to remove');
+        }
+      }
+      
+      // Now push all types
+      for (const { name, fn } of types) {
+        const typePath = path.join(basePath, name);
+        
+        // Skip if directory doesn't exist
+        if (!fs.existsSync(typePath)) {
+          continue;
+        }
+        
         logger.section(`Pushing ${name} from ${typePath}`);
         try {
           await fn(sdk, typePath);
@@ -159,6 +326,9 @@ export default async function pushController({ type, path: sourcePath }) {
 
     logger.section(`Pushing ${type} from ${targetFile ? `${basePath} (${targetFile})` : basePath}`);
 
+    // Initialize SDK for individual type pushes
+    const sdk = await initializeSdk();
+
     if (type === 'components') {
       await pushComponents(sdk, basePath, { targetFile });
     } else if (type === 'blueprints') {
@@ -205,5 +375,22 @@ export default async function pushController({ type, path: sourcePath }) {
         logger.warning(`Failed to clean up temporary directory: ${tempDir}`, error);
       }
     }
+    
+    // Handle hard push cleanup (remove resources after successful push)
+    if (process.env.QELOS_HARD_PUSH_REMOVE) {
+      try {
+        const toRemove = JSON.parse(process.env.QELOS_HARD_PUSH_REMOVE);
+        if (toRemove.length > 0) {
+          const sdk = await initializeSdk();
+          await removeResources(sdk, toRemove);
+          logger.success(`Removed ${toRemove.length} resources that no longer exist locally`);
+        }
+      } catch (error) {
+        logger.error('Failed to remove resources after push:', error);
+      } finally {
+        // Clean up the environment variable
+        delete process.env.QELOS_HARD_PUSH_REMOVE;
+      }
+    }
   }
 }

package/jest.config.js

@@ -71,20 +71,23 @@ module.exports = {
   // ],
 
   // An array of file extensions your modules use
-  // moduleFileExtensions: [
-  //   "js",
-  //   "jsx",
-  //   "ts",
-  //   "tsx",
-  //   "json",
-  //   "node"
-  // ],
+  moduleFileExtensions: [
+    "js",
+    "jsx",
+    "ts",
+    "tsx",
+    "json",
+    "node",
+    "mjs"
+  ],
 
   // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
-  // moduleNameMapper: {},
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.mjs$': '$1'
+  },
 
   // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
-  // modulePathIgnorePatterns: [],
+  modulePathIgnorePatterns: [],
 
   // Activates notifications for test results
   // notify: false,
@@ -105,7 +108,7 @@ module.exports = {
   // resetMocks: false,
 
   // Reset the module registry before running each individual test
-  // resetModules: false,
+  resetModules: false,
 
   // A path to a custom resolver
   // resolver: undefined,
@@ -137,7 +140,7 @@ module.exports = {
   // snapshotSerializers: [],
 
   // The test environment that will be used for testing
-  // testEnvironment: "jest-environment-node",
+  testEnvironment: "node",
 
   // Options that will be passed to the testEnvironment
   // testEnvironmentOptions: {},
@@ -146,10 +149,10 @@ module.exports = {
   // testLocationInResults: false,
 
   // The glob patterns Jest uses to detect test files
-  // testMatch: [
-  //   "**/__tests__/**/*.[jt]s?(x)",
-  //   "**/?(*.)+(spec|test).[tj]s?(x)"
-  // ],
+  testMatch: [
+    "**/__tests__/**/*.[jt]s?(x)",
+    "**/?(*.)+(spec|test).[tj]s?(x)"
+  ],
 
   // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
   testPathIgnorePatterns: [
@@ -173,18 +176,11 @@ module.exports = {
   // timers: "real",
 
   // A map from regular expressions to paths to transformers
-  // transform: undefined,
-
-  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
-  // transformIgnorePatterns: [
-  //   "/node_modules/",
-  //   "\\.pnp\\.[^\\/]+$"
-  // ],
-
-  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
-  // unmockedModulePathPatterns: undefined,
+  transform: {
+    '^.+\\.mjs$': 'jest-esm-transformer'
+  },
 
-  // Indicates whether each individual test should be reported during the run
+  // An array of regexp pattern strings that are matched against all source file paths before re-running tests in watch mode
   // verbose: undefined,
 
   // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qelos/plugins-cli",
-  "version": "0.0.30",
+  "version": "0.1.1",
   "description": "CLI to manage QELOS plugins",
   "main": "cli.mjs",
   "bin": {
@@ -16,7 +16,6 @@
   "dependencies": {
     "@qelos/sdk": "^3.11.1",
     "cli-progress": "^3.12.0",
-    "cli-select": "^1.1.2",
     "decompress-zip": "^0.3.3",
     "follow-redirects": "^1.15.11",
     "jiti": "^2.6.1",
@@ -29,9 +28,10 @@
     "access": "public"
   },
   "scripts": {
-    "test": "jest --runInBand"
+    "test": "NODE_OPTIONS='--experimental-vm-modules' jest --runInBand"
   },
   "devDependencies": {
-    "jest": "^27.5.1"
+    "jest": "^27.5.1",
+    "jest-esm-transformer": "^1.0.0"
   }
 }

package/services/components.mjs

@@ -186,3 +186,5 @@ export async function pullComponents(sdk, targetPath) {
   logger.info(`Saved components.json with metadata`);
   logger.info(`Pulled ${filteredComponentsInformation.length} component(s)`);
 }
+
+export { listVueFilesRecursively };

package/services/duplicate-checker.mjs

@@ -0,0 +1,118 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from './logger.mjs';
+
+/**
+ * Get the identifier field name for a resource type
+ * @param {string} resourceType - Type of resource
+ * @returns {string} - The field name used as identifier
+ */
+function getIdentifierField(resourceType) {
+  const identifierFields = {
+    blueprints: 'identifier',
+    configs: 'key',
+    plugins: 'apiPath',
+    integrations: '_id',
+    connections: '_id'
+  };
+  
+  return identifierFields[resourceType] || '_id';
+}
+
+/**
+ * Extract identifier from a resource file
+ * @param {string} filePath - Path to the resource file
+ * @param {string} resourceType - Type of resource
+ * @param {string} basePath - Base path for relative calculation (optional)
+ * @returns {string|null} - The identifier value or null if not found
+ */
+function extractIdentifier(filePath, resourceType, basePath = null) {
+  try {
+    // For JSON-based resources, parse and extract identifier
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const data = JSON.parse(content);
+    const identifierField = getIdentifierField(resourceType);
+    
+    return data[identifierField] || null;
+  } catch (error) {
+    logger.debug(`Failed to extract identifier from ${filePath}: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Check for duplicate identifiers in resource files
+ * @param {string[]} filePaths - Array of file paths to check
+ * @param {string} resourceType - Type of resource
+ * @param {string} basePath - Base path for relative calculation (optional)
+ * @returns {Object[]} - Array of duplicate groups
+ */
+function checkDuplicateIdentifiers(filePaths, resourceType, basePath = null) {
+  const identifierMap = new Map();
+  const duplicates = [];
+  
+  for (const filePath of filePaths) {
+    const identifier = extractIdentifier(filePath, resourceType, basePath);
+    
+    if (!identifier) {
+      continue; // Skip files without identifiers
+    }
+    
+    if (identifierMap.has(identifier)) {
+      // Found a duplicate
+      const existing = identifierMap.get(identifier);
+      
+      // Find if this duplicate group already exists
+      let duplicateGroup = duplicates.find(group => group.identifier === identifier);
+      
+      if (!duplicateGroup) {
+        // Create new duplicate group
+        duplicateGroup = {
+          identifier,
+          files: [existing]
+        };
+        duplicates.push(duplicateGroup);
+      }
+      
+      // Add current file to the group
+      duplicateGroup.files.push(filePath);
+    } else {
+      identifierMap.set(identifier, filePath);
+    }
+  }
+  
+  return duplicates;
+}
+
+/**
+ * Display duplicate identifier conflicts to the user
+ * @param {Object[]} duplicates - Array of duplicate groups
+ * @param {string} resourceType - Type of resource
+ */
+function displayDuplicateConflicts(duplicates, resourceType) {
+  if (duplicates.length === 0) {
+    return;
+  }
+  
+  logger.error(`\nFound ${duplicates.length} duplicate identifier conflict(s) in ${resourceType}:`);
+  
+  for (const duplicate of duplicates) {
+    logger.error(`\n  Duplicate identifier: "${duplicate.identifier}"`);
+    logger.error(`  Found in ${duplicate.files.length} files:`);
+    
+    duplicate.files.forEach(file => {
+      logger.error(`    • ${path.relative(process.cwd(), file)}`);
+    });
+    
+    logger.warning(`  Please remove one of the duplicate files and try again.`);
+  }
+  
+  logger.error('\nPush aborted due to duplicate identifiers.');
+}
+
+export {
+  getIdentifierField,
+  extractIdentifier,
+  checkDuplicateIdentifiers,
+  displayDuplicateConflicts
+};

package/services/git-files.mjs

@@ -73,13 +73,17 @@ function getCommittedFiles() {
 }
 
 /**
- * Get the list of staged files
+ * Get the list of staged files (excluding deleted files)
  * @returns {string[]} Array of file paths
  */
 function getStagedFiles() {
   try {
-    const output = execSync('git diff --cached --name-only', { encoding: 'utf-8' });
-    return output.trim().split('\n').filter(file => file);
+    // Use --name-status to get file status, then filter out deleted files (status D)
+    const output = execSync('git diff --cached --name-status', { encoding: 'utf-8' });
+    return output.trim()
+      .split('\n')
+      .filter(line => line && !line.startsWith('D')) // Skip deleted files
+      .map(line => line.substring(1).trim()); // Remove status prefix and get file path
   } catch (error) {
     logger.error('Failed to get staged files', error);
     throw new Error('Unable to retrieve staged files from git');
@@ -130,11 +134,95 @@ function findReferencingConfigs(refPath, basePath) {
   return referencingConfigs;
 }
 
+/**
+ * Find plugins that reference a specific HTML file through $ref
+ * @param {string} htmlRelativePath - Relative path of the HTML file from the plugin directory
+ * @param {string} basePath - Base path to search for plugins
+ * @returns {Array} Array of plugin.json file paths that reference the HTML file
+ */
+function findReferencingPlugins(htmlRelativePath, basePath) {
+  const referencingPlugins = [];
+  // Ensure basePath is absolute
+  const absoluteBasePath = path.resolve(basePath);
+  const pluginsDir = path.join(absoluteBasePath, 'plugins');
+  
+  if (!fs.existsSync(pluginsDir)) {
+    return referencingPlugins;
+  }
+  
+  // Get all plugin directories and .plugin.json files in the plugins directory
+  const pluginDirs = fs.readdirSync(pluginsDir, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory())
+    .map(dirent => dirent.name);
+  
+  // Also check for .plugin.json files directly in the plugins directory
+  const pluginFiles = fs.readdirSync(pluginsDir)
+    .filter(file => file.endsWith('.plugin.json'));
+  
+  // Check plugin files in subdirectories
+  for (const pluginDir of pluginDirs) {
+    const pluginJsonPath = path.join(pluginsDir, pluginDir, 'plugin.json');
+    
+    if (fs.existsSync(pluginJsonPath)) {
+      try {
+        const content = fs.readFileSync(pluginJsonPath, 'utf-8');
+        const plugin = JSON.parse(content);
+        
+        // Check all $ref references in the plugin
+        const refs = findAllRefs(plugin);
+        
+        // Check if any ref matches our target HTML file
+        // The ref might be like "./micro-frontends/categories.html"
+        for (const ref of refs) {
+          if (ref.includes(htmlRelativePath) || ref.endsWith(path.basename(htmlRelativePath))) {
+            if (!referencingPlugins.includes(pluginJsonPath)) {
+              referencingPlugins.push(pluginJsonPath);
+            }
+            logger.debug(`Plugin ${pluginDir} references HTML file: ${ref}`);
+            break;
+          }
+        }
+      } catch (error) {
+        logger.warning(`Error reading plugin.json ${pluginJsonPath}: ${error.message}`);
+      }
+    }
+  }
+  
+  // Check .plugin.json files directly in plugins directory
+  for (const pluginFile of pluginFiles) {
+    const pluginJsonPath = path.join(pluginsDir, pluginFile);
+    
+    try {
+      const content = fs.readFileSync(pluginJsonPath, 'utf-8');
+      const plugin = JSON.parse(content);
+      
+      // Check all $ref references in the plugin
+      const refs = findAllRefs(plugin);
+      
+      // Check if any ref matches our target HTML file
+      // The ref might be like "./micro-frontends/categories.html"
+      for (const ref of refs) {
+        if (ref.includes(htmlRelativePath) || ref.endsWith(path.basename(htmlRelativePath))) {
+          if (!referencingPlugins.includes(pluginJsonPath)) {
+            referencingPlugins.push(pluginJsonPath);
+          }
+          logger.debug(`Plugin ${pluginFile} references HTML file: ${ref}`);
+          break;
+        }
+      }
+    } catch (error) {
+      logger.warning(`Error reading plugin.json ${pluginJsonPath}: ${error.message}`);
+    }
+  }
+  
+  return referencingPlugins;
+}
+
 /**
  * Find integration files that reference a specific file via $ref
- * @param {string} refPath - The referenced file path (relative)
+ * @param {string} refPath - Reference path to look for
  * @param {string} basePath - Base path to search for integrations
- * @returns {string[]} Array of integration file paths that reference the file
+ * @returns {Array} Array of integration file paths that reference the target
  */
 function findReferencingIntegrations(refPath, basePath) {
   const referencingIntegrations = [];
@@ -240,21 +328,23 @@ function classifyFiles(files, basePath) {
     const basename = path.basename(fullPath, ext);
 
     // Check for specific file types
-    if (relativePath.includes('components/') && ext === '.vue') {
+    if (relativePath.startsWith('components/') && ext === '.vue') {
       classified.components.push(fullPath);
-    } else if (relativePath.includes('blueprints/') && ext === '.json') {
+    } else if (relativePath.startsWith('blueprints/') && ext === '.json') {
       classified.blueprints.push(fullPath);
-    } else if (relativePath.includes('configs/') && ext === '.json') {
+    } else if (relativePath.startsWith('configs/') && ext === '.json') {
       classified.configs.push(fullPath);
-    } else if (relativePath.includes('plugins/') && ext === '.json') {
-      classified.plugins.push(fullPath);
-    } else if (relativePath.includes('blocks/') && ext === '.json') {
+    } else if (relativePath.startsWith('plugins/') && ext === '.json') {
+      if (!classified.plugins.includes(fullPath)) {
+        classified.plugins.push(fullPath);
+      }
+    } else if (relativePath.startsWith('blocks/') && ext === '.json') {
       classified.blocks.push(fullPath);
-    } else if (relativePath.includes('integrations/') && ext === '.json') {
+    } else if (relativePath.startsWith('integrations/') && ext === '.json') {
       classified.integrations.push(fullPath);
-    } else if (relativePath.includes('connections/') && ext === '.json') {
+    } else if (relativePath.startsWith('connections/') && ext === '.json') {
       classified.connections.push(fullPath);
-    } else if (dir.includes('prompts') && ext === '.md') {
+    } else if (relativePath.startsWith('integrations/prompts/') && ext === '.md') {
       // Find integrations that reference this prompt file
       classified.prompts.push(fullPath);
       
@@ -277,7 +367,7 @@ function classifyFiles(files, basePath) {
       // 2. In configs directory -> These are typically referenced by configs, not pushed directly
       // 3. Other locations -> treat as micro-frontends
       
-      if (relativePath.includes('configs/') || relativePath.includes('configs\\')) {
+      if (relativePath.startsWith('configs/') || relativePath.startsWith('configs\\')) {
         // HTML file in configs directory - these are usually referenced by config files, not pushed directly
         logger.debug(`Found HTML file in configs directory (will be pushed via referencing config): ${relativePath}`);
         
@@ -296,44 +386,41 @@ function classifyFiles(files, basePath) {
         // Find plugins that contain this HTML file (micro-frontends)
         classified.microFrontends.push(fullPath);
         
-        // For HTML files, we need to find which plugin contains them
-        // HTML files in plugins are typically part of the plugin structure
-        let pluginDir = path.dirname(fullPath);
-        let pluginJson = path.join(pluginDir, 'plugin.json');
+        // For HTML files, we need to find which plugin references them
+        // The HTML file should be in a micro-frontends directory within a plugin
+        const htmlBasename = path.basename(fullPath);
         
-        // 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');
+        // Try to find plugins that reference this HTML file
+        // The ref path should be relative to the plugin directory
+        // e.g., "./micro-frontends/categories.html"
+        let refPath = `./micro-frontends/${htmlBasename}`;
+        
+        // If the file is in a nested path, preserve that structure
+        if (relativePath.startsWith('plugins/micro-frontends/')) {
+          const parts = relativePath.split('plugins/micro-frontends/');
+          if (parts[1]) {
+            refPath = `./micro-frontends/${parts[1]}`;
           }
-          
-          // 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;
-              }
-            }
+        } else if (relativePath.includes('micro-frontends/')) {
+          // Handle other micro-frontends paths
+          const parts = relativePath.split('micro-frontends/');
+          if (parts[1]) {
+            refPath = `./micro-frontends/${parts[1]}`;
           }
         }
         
-        if (fs.existsSync(pluginJson)) {
-          // This HTML file is part of a plugin
-          if (!classified.plugins.includes(pluginJson)) {
-            classified.plugins.push(pluginJson);
-            logger.debug(`Found plugin containing HTML ${relativePath}: ${path.basename(pluginJson)}`);
+        const referencingPlugins = findReferencingPlugins(refPath, basePath);
+        
+        // Add all referencing plugins to the classified list
+        for (const pluginPath of referencingPlugins) {
+          if (!classified.plugins.includes(pluginPath)) {
+            classified.plugins.push(pluginPath);
+            logger.debug(`Found plugin referencing HTML ${relativePath}: ${path.basename(pluginPath)}`);
           }
-        } else {
-          logger.warning(`Could not find plugin.json for HTML file: ${relativePath}`);
+        }
+        
+        if (referencingPlugins.length === 0) {
+          logger.warning(`Could not find any plugin referencing HTML file: ${relativePath} (searched for ref: ${refPath})`);
         }
       }
     } else {

package/services/hard-push.mjs

@@ -0,0 +1,124 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { red, yellow } from '../utils/colors.mjs';
+import { logger } from './logger.mjs';
+import { confirmDialog } from './interactive-select.mjs';
+
+/**
+ * Get local files from directory
+ */
+export function getLocalFiles(typePath, type) {
+  if (!fs.existsSync(typePath)) return [];
+  
+  const files = fs.readdirSync(typePath);
+  return files.filter(file => {
+    if (type === 'components') return file.endsWith('.vue');
+    if (type === 'blueprints') return file.endsWith('.blueprint.json');
+    if (type === 'plugins') return file.endsWith('.plugin.json');
+    if (type === 'integrations') return file.endsWith('.integration.json');
+    return false;
+  });
+}
+
+/**
+ * Get remote resources from Qelos
+ */
+export async function getRemoteResources(sdk, type) {
+  try {
+    switch (type) {
+      case 'components':
+        return await sdk.components.getList();
+      case 'blueprints':
+        return await sdk.manageBlueprints.getList();
+      case 'plugins':
+        return await sdk.managePlugins.getList();
+      case 'integrations':
+        return await sdk.integrations.getList();
+      default:
+        return [];
+    }
+  } catch (error) {
+    logger.error(`Failed to fetch remote ${type}:`, error);
+    return [];
+  }
+}
+
+/**
+ * Extract identifier from filename
+ */
+export function getIdentifierFromFile(filename, type) {
+  if (type === 'components') {
+    return filename.replace('.vue', '');
+  }
+  if (type === 'blueprints') {
+    return filename.replace('.blueprint.json', '');
+  }
+  if (type === 'plugins') {
+    return filename.replace('.plugin.json', '');
+  }
+  if (type === 'integrations') {
+    return filename.replace('.integration.json', '');
+  }
+  return filename;
+}
+
+/**
+ * Show warning and get confirmation for hard push
+ */
+export async function confirmHardPush(toRemove) {
+  console.log(yellow('\n⚠️  WARNING: You are using the --hard flag'));
+  console.log(yellow('This will permanently remove resources from Qelos that don\'t exist locally.\n'));
+  
+  console.log(red('The following resources will be removed:'));
+  toRemove.forEach(({ type, identifier }) => {
+    console.log(red(`  - ${type}: ${identifier}`));
+  });
+  
+  const message = '\nDo you want to continue?';
+  return await confirmDialog(message, false, { 
+    noLabel: 'No (default)', 
+    yesLabel: 'Yes, remove them' 
+  });
+}
+
+/**
+ * Remove resources from Qelos
+ */
+export async function removeResources(sdk, toRemove) {
+  for (const { type, identifier } of toRemove) {
+    try {
+      switch (type) {
+        case 'components':
+          // For components, we need to find the component by identifier first
+          const components = await sdk.components.getList();
+          const component = components.find(c => c.identifier === identifier);
+          if (component) {
+            await sdk.components.remove(component._id);
+          }
+          break;
+        case 'blueprints':
+          await sdk.manageBlueprints.remove(identifier);
+          break;
+        case 'plugins':
+          // For plugins, we need to find the plugin by key first
+          const plugins = await sdk.managePlugins.getList();
+          const plugin = plugins.find(p => p.key === identifier);
+          if (plugin) {
+            await sdk.managePlugins.remove(plugin._id);
+          }
+          break;
+        case 'integrations':
+          // For integrations, we need to find the integration by identifier first
+          const integrations = await sdk.integrations.getList();
+          const integration = integrations.find(i => i.identifier === identifier);
+          if (integration) {
+            await sdk.integrations.remove(integration._id);
+          }
+          break;
+      }
+      logger.info(`Removed ${type}: ${identifier}`);
+    } catch (error) {
+      logger.error(`Failed to remove ${type}: ${identifier}`, error);
+    }
+  }
+}

package/services/integrations.mjs

@@ -6,6 +6,7 @@ import { extractIntegrationContent, resolveReferences } from './file-refs.mjs';
 const INTEGRATION_FILE_EXTENSION = '.integration.json';
 const INTEGRATIONS_API_PATH = '/api/integrations';
 const SERVER_ONLY_FIELDS = ['tenant', 'plugin', 'user', 'created', 'updated', '__v'];
+const CONNECTION_FILE_EXTENSION = '.connection.json';
 
 function slugify(value = '') {
   return value
@@ -101,6 +102,136 @@ async function fetchIntegrations(sdk) {
   return sdk.callJsonApi(INTEGRATIONS_API_PATH);
 }
 
+/**
+ * Load all connection files and create a map of _id to file path
+ * @param {string} basePath - Base path to search for connection files
+ * @returns {Map<string, string>} Map of connection ID to relative file path
+ */
+function loadConnectionIdMap(basePath) {
+  const connectionMap = new Map();
+  
+  // Check if connections directory exists
+  const connectionsPath = join(basePath, 'connections');
+  if (!fs.existsSync(connectionsPath)) {
+    logger.warning('Connections directory not found, connection references will not be mapped');
+    return connectionMap;
+  }
+  
+  try {
+    const connectionFiles = fs.readdirSync(connectionsPath)
+      .filter(file => file.endsWith(CONNECTION_FILE_EXTENSION));
+    
+    for (const file of connectionFiles) {
+      const filePath = join(connectionsPath, file);
+      try {
+        const connectionData = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        if (connectionData._id) {
+          // Store relative path from the integrations directory
+          const relativePath = `./connections/${file}`;
+          connectionMap.set(connectionData._id, relativePath);
+          logger.debug(`Mapped connection ID ${connectionData._id} to ${relativePath}`);
+        }
+      } catch (error) {
+        logger.warning(`Failed to read connection file ${file}: ${error.message}`);
+      }
+    }
+    
+    logger.info(`Loaded ${connectionMap.size} connection mappings`);
+  } catch (error) {
+    logger.error('Failed to load connection files', error);
+  }
+  
+  return connectionMap;
+}
+
+/**
+ * Replace connection IDs with $refId objects in an integration
+ * @param {Object} integration - Integration object
+ * @param {Map<string, string>} connectionMap - Map of connection ID to file path
+ * @returns {Object} Integration with connection IDs replaced by $refId objects
+ */
+function replaceConnectionIds(integration, connectionMap) {
+  const updated = JSON.parse(JSON.stringify(integration));
+  
+  // Replace trigger.source if it's a connection ID
+  if (updated.trigger?.source && typeof updated.trigger.source === 'string') {
+    const connectionPath = connectionMap.get(updated.trigger.source);
+    if (connectionPath) {
+      updated.trigger.source = { $refId: connectionPath };
+      logger.debug(`Replaced trigger.source ${integration.trigger.source} with ${connectionPath}`);
+    }
+  }
+  
+  // Replace target.source if it's a connection ID
+  if (updated.target?.source && typeof updated.target.source === 'string') {
+    const connectionPath = connectionMap.get(updated.target.source);
+    if (connectionPath) {
+      updated.target.source = { $refId: connectionPath };
+      logger.debug(`Replaced target.source ${integration.target.source} with ${connectionPath}`);
+    }
+  }
+  
+  return updated;
+}
+
+/**
+ * Resolve $refId objects to actual connection IDs
+ * @param {Object} integration - Integration object with potential $refId references
+ * @param {string} basePath - Base path for resolving connection files
+ * @returns {Object} Integration with $refId objects resolved to IDs
+ */
+function resolveConnectionReferences(integration, basePath) {
+  const updated = JSON.parse(JSON.stringify(integration));
+  
+  // Resolve trigger.source if it's a $refId object
+  if (updated.trigger?.source && typeof updated.trigger.source === 'object' && updated.trigger.source.$refId) {
+    const connectionPath = updated.trigger.source.$refId;
+    const fullConnectionPath = join(basePath, connectionPath);
+    
+    try {
+      if (fs.existsSync(fullConnectionPath)) {
+        const connectionData = JSON.parse(fs.readFileSync(fullConnectionPath, 'utf-8'));
+        if (connectionData._id) {
+          updated.trigger.source = connectionData._id;
+          logger.debug(`Resolved trigger.source ${connectionPath} to ID ${connectionData._id}`);
+        } else {
+          throw new Error('Connection file missing _id field');
+        }
+      } else {
+        throw new Error(`Connection file not found: ${fullConnectionPath}`);
+      }
+    } catch (error) {
+      logger.error(`Failed to resolve trigger.source reference ${connectionPath}: ${error.message}`);
+      throw error;
+    }
+  }
+  
+  // Resolve target.source if it's a $refId object
+  if (updated.target?.source && typeof updated.target.source === 'object' && updated.target.source.$refId) {
+    const connectionPath = updated.target.source.$refId;
+    const fullConnectionPath = join(basePath, connectionPath);
+    
+    try {
+      if (fs.existsSync(fullConnectionPath)) {
+        const connectionData = JSON.parse(fs.readFileSync(fullConnectionPath, 'utf-8'));
+        if (connectionData._id) {
+          updated.target.source = connectionData._id;
+          logger.debug(`Resolved target.source ${connectionPath} to ID ${connectionData._id}`);
+        } else {
+          throw new Error('Connection file missing _id field');
+        }
+      } else {
+        throw new Error(`Connection file not found: ${fullConnectionPath}`);
+      }
+    } catch (error) {
+      logger.error(`Failed to resolve target.source reference ${connectionPath}: ${error.message}`);
+      throw error;
+    }
+  }
+  
+  return updated;
+}
+
 async function createIntegration(sdk, payload) {
   return sdk.callJsonApi(INTEGRATIONS_API_PATH, {
     method: 'post',
@@ -138,13 +269,19 @@ export async function pullIntegrations(sdk, targetPath) {
 
   logger.info(`Found ${integrations.length} integration(s) to pull`);
 
+  // Load connection ID mappings before processing integrations
+  const connectionMap = loadConnectionIdMap(targetPath);
+
   const usedNames = new Set();
   integrations.forEach((integration, index) => {
     const fileName = buildFileName(integration, index, usedNames);
     const filePath = join(targetPath, fileName);
     
+    // Replace connection IDs with $refId references
+    const integrationWithRefs = replaceConnectionIds(integration, connectionMap);
+    
     // Extract content to files for AI agents
-    const processedIntegration = extractIntegrationContent(integration, targetPath, fileName);
+    const processedIntegration = extractIntegrationContent(integrationWithRefs, targetPath, fileName);
     
     writeIntegrationFile(filePath, sanitizeIntegrationForFile(processedIntegration));
     logger.step(`Pulled: ${getIntegrationDisplayName(integration) || integration._id || fileName}`);
@@ -178,8 +315,11 @@ export async function pushIntegrations(sdk, path, options = {}) {
       const integrationData = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
       validateIntegrationPayload(integrationData, file);
       
+      // Resolve $refId objects to actual connection IDs
+      const integrationWithResolvedRefs = resolveConnectionReferences(integrationData, path);
+      
       // Resolve any $ref references in the integration
-      const resolvedIntegration = await resolveReferences(integrationData, path);
+      const resolvedIntegration = await resolveReferences(integrationWithResolvedRefs, path);
       
       const payload = toRequestPayload(resolvedIntegration);
       const displayName = getIntegrationDisplayName(resolvedIntegration) || file.replace(INTEGRATION_FILE_EXTENSION, '');
@@ -199,8 +339,12 @@ export async function pushIntegrations(sdk, path, options = {}) {
       // This ensures pre_messages are stored as prompt md files after pushing
       const processedResponse = extractIntegrationContent(response, path, file);
       
+      // Replace connection IDs with $refId objects again for the stored file
+      const connectionMap = loadConnectionIdMap(path);
+      const finalIntegration = replaceConnectionIds(processedResponse, connectionMap);
+      
       // Persist returned integration (with _id) back to disk
-      writeIntegrationFile(filePath, sanitizeIntegrationForFile(processedResponse));
+      writeIntegrationFile(filePath, sanitizeIntegrationForFile(finalIntegration));
       
       results.push({ status: 'fulfilled' });
     } catch (error) {
@@ -220,3 +364,6 @@ export async function pushIntegrations(sdk, path, options = {}) {
 
   logger.info(`Pushed ${integrationFiles.length} integration(s)`);
 }
+
+// Export helper functions for testing
+export { loadConnectionIdMap, replaceConnectionIds, resolveConnectionReferences };

package/services/interactive-select.mjs

@@ -0,0 +1,102 @@
+import * as readline from 'node:readline';
+
+/**
+ * Create an interactive selection with arrow key support
+ * @param {Object} options - Selection options
+ * @param {Object} options.values - Key-value pairs of option id and label
+ * @param {string} [options.defaultValue] - Default option id
+ * @param {string} [options.message] - Message to display
+ * @returns {Promise<{id: string, value: string}>} Selected option
+ */
+export async function interactiveSelect({ values, defaultValue, message }) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    // Hide cursor for cleaner display
+    process.stdout.write('\x1B[?25l');
+    
+    const options = Object.entries(values);
+    let selectedIndex = defaultValue ? options.findIndex(([id]) => id === defaultValue) : 0;
+    
+    if (message) {
+      console.log(message);
+    }
+    
+    const render = () => {
+      // Move cursor up to overwrite previous options
+      process.stdout.write('\x1B[2K\r');
+      for (let i = 0; i < options.length; i++) {
+        if (i === 0) {
+          process.stdout.write('\x1B[2K\r');
+        } else {
+          process.stdout.write('\n\x1B[2K\r');
+        }
+        
+        if (i === selectedIndex) {
+          process.stdout.write(`(•) ${options[i][1]}`);
+        } else {
+          process.stdout.write(`( ) ${options[i][1]}`);
+        }
+      }
+      
+      // Move cursor back to first option
+      if (options.length > 1) {
+        process.stdout.write(`\x1B[${options.length - 1}A`);
+      }
+    };
+    
+    const cleanup = () => {
+      process.stdout.write('\x1B[?25h'); // Show cursor
+      rl.close();
+    };
+    
+    render();
+    
+    // Handle stdin for arrow keys and Enter
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    
+    process.stdin.on('keypress', (str, key) => {
+      if (key.name === 'up') {
+        selectedIndex = Math.max(0, selectedIndex - 1);
+        render();
+      } else if (key.name === 'down') {
+        selectedIndex = Math.min(options.length - 1, selectedIndex + 1);
+        render();
+      } else if (key.name === 'return' || key.name === 'enter') {
+        cleanup();
+        console.log(); // Add newline after selection
+        resolve({ id: options[selectedIndex][0], value: options[selectedIndex][1] });
+      } else if (key.name === 'escape' || key.ctrl && key.name === 'c') {
+        cleanup();
+        console.log('\nOperation cancelled.');
+        process.exit(0);
+      }
+    });
+  });
+}
+
+/**
+ * Create a yes/no confirmation dialog
+ * @param {string} message - Message to display
+ * @param {boolean} [defaultValue=false] - Default value
+ * @param {Object} [options] - Additional options
+ * @param {string} [options.noLabel='No'] - Label for No option
+ * @param {string} [options.yesLabel='Yes'] - Label for Yes option
+ * @returns {Promise<boolean>} User's choice
+ */
+export async function confirmDialog(message, defaultValue = false, { noLabel = 'No', yesLabel = 'Yes' } = {}) {
+  const result = await interactiveSelect({
+    values: {
+      no: noLabel,
+      yes: yesLabel
+    },
+    defaultValue: defaultValue ? 'yes' : 'no',
+    message
+  });
+  
+  return result.id === 'yes';
+}