easybuild-nox 1.0.0

package/src/utils/modules.js

@@ -0,0 +1,571 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { spawn, execSync } = require('child_process');
+const logger = require('./logger');
+
+const EASY_HOME = path.join(os.homedir(), '.easy');
+const SHARED_MODULES = path.join(EASY_HOME, 'modules');
+const MODULES_CACHE = path.join(EASY_HOME, 'cache');
+const MODULES_DB = path.join(EASY_HOME, 'modules.json');
+const ELECTRON_DIR = path.join(EASY_HOME, 'electron');
+
+// Special packages that need special handling
+const SPECIAL_PACKAGES = {
+  electron: {
+    handler: 'installElectron',
+    description: 'Electron binary (downloaded separately)',
+  },
+  '@electron/remote': {
+    handler: 'installElectron',
+    description: 'Electron remote module',
+  },
+};
+
+class SharedModules {
+  constructor() {
+    this.initialized = false;
+  }
+
+  async init() {
+    if (this.initialized) return;
+
+    await fs.ensureDir(EASY_HOME);
+    await fs.ensureDir(SHARED_MODULES);
+    await fs.ensureDir(MODULES_CACHE);
+
+    if (!(await fs.pathExists(MODULES_DB))) {
+      await fs.writeJson(MODULES_DB, { modules: {}, lastUpdate: null }, { spaces: 2 });
+    }
+
+    this.initialized = true;
+  }
+
+  async getModulesDb() {
+    await this.init();
+    return await fs.readJson(MODULES_DB);
+  }
+
+  async saveModulesDb(db) {
+    await this.init();
+    await fs.writeJson(MODULES_DB, db, { spaces: 2 });
+  }
+
+  async isModuleInstalled(name, version = '*') {
+    await this.init();
+    const db = await this.getModulesDb();
+    const moduleKey = `${name}@${version}`;
+
+    if (!db.modules[moduleKey]) return false;
+
+    const modulePath = path.join(SHARED_MODULES, name);
+    return await fs.pathExists(modulePath);
+  }
+
+  async installModule(name, version = '*', options = {}) {
+    await this.init();
+    const db = await this.getModulesDb();
+    const moduleKey = `${name}@${version}`;
+
+    // Check if already installed
+    if (await this.isModuleInstalled(name, version) && !options.force) {
+      logger.dim(`  ${name}@${version} already installed`);
+      return { installed: false, cached: true };
+    }
+
+    // Handle special packages like Electron
+    if (SPECIAL_PACKAGES[name]) {
+      return await this.installSpecialPackage(name, version, options);
+    }
+
+    // Install to shared folder
+    logger.info(`  Installing ${name}@${version}...`);
+
+    try {
+      // Create package.json for the module
+      const tempDir = path.join(MODULES_CACHE, `install-${Date.now()}`);
+      await fs.ensureDir(tempDir);
+
+      await fs.writeJson(path.join(tempDir, 'package.json'), {
+        name: 'temp-install',
+        version: '1.0.0',
+        dependencies: {
+          [name]: version,
+        },
+      });
+
+      // Run npm install in temp directory
+      await this.runNpmInstall(tempDir);
+
+      // Move to shared modules
+      const installedPath = path.join(tempDir, 'node_modules', name);
+      if (await fs.pathExists(installedPath)) {
+        const modulePath = path.join(SHARED_MODULES, name);
+        await fs.remove(modulePath);
+        await fs.move(installedPath, modulePath);
+
+        // Update database
+        db.modules[moduleKey] = {
+          name,
+          version,
+          installedAt: new Date().toISOString(),
+          path: modulePath,
+        };
+        await this.saveModulesDb(db);
+      }
+
+      // Cleanup temp directory
+      await fs.remove(tempDir);
+
+      logger.dim(`  ${name}@${version} installed`);
+      return { installed: true, cached: false };
+    } catch (error) {
+      logger.error(`  Failed to install ${name}: ${error.message}`);
+      return { installed: false, cached: false, error: error.message };
+    }
+  }
+
+  async installSpecialPackage(name, version, options) {
+    await this.init();
+    const db = await this.getModulesDb();
+    const moduleKey = `${name}@${version}`;
+
+    logger.info(`  Installing ${name} (special handling)...`);
+
+    try {
+      if (name === 'electron') {
+        return await this.installElectron(version, options);
+      }
+
+      // For other special packages, use regular install
+      const tempDir = path.join(MODULES_CACHE, `install-${Date.now()}`);
+      await fs.ensureDir(tempDir);
+
+      await fs.writeJson(path.join(tempDir, 'package.json'), {
+        name: 'temp-install',
+        version: '1.0.0',
+        dependencies: { [name]: version },
+      });
+
+      await this.runNpmInstall(tempDir);
+
+      const installedPath = path.join(tempDir, 'node_modules', name);
+      const modulePath = path.join(SHARED_MODULES, name);
+      
+      if (await fs.pathExists(installedPath)) {
+        await fs.remove(modulePath);
+        await fs.move(installedPath, modulePath);
+
+        db.modules[moduleKey] = {
+          name,
+          version,
+          installedAt: new Date().toISOString(),
+          path: modulePath,
+        };
+        await this.saveModulesDb(db);
+      }
+
+      await fs.remove(tempDir);
+      logger.dim(`  ${name}@${version} installed`);
+      return { installed: true, cached: false };
+
+    } catch (error) {
+      logger.error(`  Failed to install ${name}: ${error.message}`);
+      return { installed: false, cached: false, error: error.message };
+    }
+  }
+
+  async installElectron(version, options) {
+    await fs.ensureDir(ELECTRON_DIR);
+    
+    const db = await this.getModulesDb();
+    const electronVersion = version === '*' ? 'latest' : version;
+    const moduleKey = `electron@${electronVersion}`;
+
+    // Check if electron is already installed
+    const electronPath = path.join(ELECTRON_DIR, 'dist', 'electron');
+    if (await fs.pathExists(electronPath) && !options.force) {
+      logger.dim('  Electron already installed');
+      
+      // Update database
+      db.modules[moduleKey] = {
+        name: 'electron',
+        version: electronVersion,
+        installedAt: new Date().toISOString(),
+        path: ELECTRON_DIR,
+      };
+      await this.saveModulesDb(db);
+      
+      return { installed: false, cached: true };
+    }
+
+    logger.info('  Downloading Electron binary...');
+    logger.dim('  This may take a few minutes...');
+
+    // Create temp directory for electron installation
+    const tempDir = path.join(MODULES_CACHE, `electron-${Date.now()}`);
+    await fs.ensureDir(tempDir);
+
+    try {
+      // Create package.json for electron
+      await fs.writeJson(path.join(tempDir, 'package.json'), {
+        name: 'temp-electron',
+        version: '1.0.0',
+        dependencies: {
+          electron: electronVersion,
+        },
+      });
+
+      // Install electron with special flags
+      await new Promise((resolve, reject) => {
+        const child = spawn('npm', ['install', '--ignore-scripts'], {
+          cwd: tempDir,
+          stdio: 'pipe',
+          shell: false,
+        });
+
+        child.on('close', (code) => {
+          if (code === 0) resolve();
+          else reject(new Error('npm install failed'));
+        });
+
+        child.on('error', reject);
+      });
+
+      // Run electron's postinstall to download the binary
+      await new Promise((resolve, reject) => {
+        const child = spawn('node', ['node_modules/electron/install.js'], {
+          cwd: tempDir,
+          stdio: 'inherit',
+          shell: false,
+          env: {
+            ...process.env,
+            ELECTRON_MIRROR: 'https://github.com/nicedoc/electron/releases/download/v',
+          },
+        });
+
+        child.on('close', (code) => {
+          if (code === 0) resolve();
+          else reject(new Error('Electron binary download failed'));
+        });
+
+        child.on('error', reject);
+      });
+
+      // Move to electron directory
+      const installedPath = path.join(tempDir, 'node_modules', 'electron');
+      if (await fs.pathExists(installedPath)) {
+        await fs.remove(ELECTRON_DIR);
+        await fs.move(installedPath, ELECTRON_DIR);
+
+        // Update database
+        db.modules[moduleKey] = {
+          name: 'electron',
+          version: electronVersion,
+          installedAt: new Date().toISOString(),
+          path: ELECTRON_DIR,
+        };
+        await this.saveModulesDb(db);
+      }
+
+      // Cleanup
+      await fs.remove(tempDir);
+
+      logger.dim('  Electron installed successfully');
+      return { installed: true, cached: false };
+
+    } catch (error) {
+      // Cleanup on error
+      await fs.remove(tempDir);
+      throw error;
+    }
+  }
+
+  async installFromPackageJson(packageJsonPath, options = {}) {
+    await this.init();
+    const pkg = await fs.readJson(packageJsonPath);
+    const dependencies = pkg.dependencies || {};
+    const devDependencies = pkg.devDependencies || {};
+
+    const allDeps = { ...dependencies, ...devDependencies };
+    const results = { installed: 0, cached: 0, failed: 0 };
+
+    logger.info('Resolving dependencies from package.json...');
+
+    for (const [name, version] of Object.entries(allDeps)) {
+      const result = await this.installModule(name, version, options);
+      if (result.installed) results.installed++;
+      else if (result.cached) results.cached++;
+      else results.failed++;
+    }
+
+    return results;
+  }
+
+  async updateAllModules(options = {}) {
+    await this.init();
+    const db = await this.getModulesDb();
+    const results = { updated: 0, failed: 0 };
+
+    logger.info('Updating all shared modules...');
+
+    for (const [moduleKey, moduleInfo] of Object.entries(db.modules)) {
+      try {
+        logger.info(`  Updating ${moduleInfo.name}...`);
+
+        // Remove old version
+        const modulePath = path.join(SHARED_MODULES, moduleInfo.name);
+        if (await fs.pathExists(modulePath)) {
+          await fs.remove(modulePath);
+        }
+
+        // Reinstall
+        const result = await this.installModule(moduleInfo.name, moduleInfo.version, { force: true });
+        if (result.installed) results.updated++;
+        else results.failed++;
+      } catch (error) {
+        logger.error(`  Failed to update ${moduleInfo.name}: ${error.message}`);
+        results.failed++;
+      }
+    }
+
+    db.lastUpdate = new Date().toISOString();
+    await this.saveModulesDb(db);
+
+    return results;
+  }
+
+  async updateModule(name, options = {}) {
+    await this.init();
+    const db = await this.getModulesDb();
+
+    // Find all versions of this module
+    const moduleEntries = Object.entries(db.modules).filter(
+      ([key, info]) => info.name === name
+    );
+
+    if (moduleEntries.length === 0) {
+      logger.warning(`Module ${name} not found in shared modules`);
+      return { updated: false };
+    }
+
+    for (const [moduleKey, moduleInfo] of moduleEntries) {
+      logger.info(`  Updating ${moduleInfo.name}@${moduleInfo.version}...`);
+
+      // Remove old version
+      const modulePath = path.join(SHARED_MODULES, moduleInfo.name);
+      if (await fs.pathExists(modulePath)) {
+        await fs.remove(modulePath);
+      }
+
+      // Reinstall
+      await this.installModule(moduleInfo.name, moduleInfo.version, { force: true });
+    }
+
+    return { updated: true };
+  }
+
+  async listModules() {
+    await this.init();
+    const db = await this.getModulesDb();
+    return db.modules;
+  }
+
+  async getModulePath(name) {
+    await this.init();
+    const modulePath = path.join(SHARED_MODULES, name);
+    if (await fs.pathExists(modulePath)) {
+      return modulePath;
+    }
+    return null;
+  }
+
+  async cleanUnused() {
+    await this.init();
+    const db = await this.getModulesDb();
+    const results = { removed: 0, kept: 0 };
+
+    logger.info('Cleaning unused modules...');
+
+    // Get all projects that use easy
+    const projects = await this.findEasyProjects();
+
+    // Get all dependencies used by projects
+    const usedModules = new Set();
+    for (const project of projects) {
+      try {
+        const pkg = await fs.readJson(path.join(project, 'package.json'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        for (const [name] of Object.entries(deps)) {
+          usedModules.add(name);
+        }
+      } catch (e) {
+        // Skip invalid projects
+      }
+    }
+
+    // Remove unused modules
+    for (const [moduleKey, moduleInfo] of Object.entries(db.modules)) {
+      if (!usedModules.has(moduleInfo.name)) {
+        const modulePath = path.join(SHARED_MODULES, moduleInfo.name);
+        if (await fs.pathExists(modulePath)) {
+          await fs.remove(modulePath);
+          delete db.modules[moduleKey];
+          logger.dim(`  Removed ${moduleInfo.name}`);
+          results.removed++;
+        }
+      } else {
+        results.kept++;
+      }
+    }
+
+    await this.saveModulesDb(db);
+    return results;
+  }
+
+  async findEasyProjects() {
+    const projects = [];
+    const homeDir = os.homedir();
+
+    // Check common locations
+    const locations = [
+      path.join(homeDir, 'projects'),
+      path.join(homeDir, 'dev'),
+      path.join(homeDir, 'code'),
+      path.join(homeDir, 'workspace'),
+      path.join(homeDir, 'repos'),
+    ];
+
+    for (const location of locations) {
+      if (await fs.pathExists(location)) {
+        const items = await fs.readdir(location);
+        for (const item of items) {
+          const itemPath = path.join(location, item);
+          const stat = await fs.stat(itemPath);
+          if (stat.isDirectory()) {
+            if (await fs.pathExists(path.join(itemPath, 'package.json'))) {
+              projects.push(itemPath);
+            }
+          }
+        }
+      }
+    }
+
+    return projects;
+  }
+
+  async getStats() {
+    await this.init();
+    const db = await this.getModulesDb();
+    const moduleCount = Object.keys(db.modules).length;
+
+    // Calculate total size
+    let totalSize = 0;
+    const items = await fs.readdir(SHARED_MODULES);
+    for (const item of items) {
+      const itemPath = path.join(SHARED_MODULES, item);
+      const stat = await fs.stat(itemPath);
+      totalSize += stat.size;
+    }
+
+    return {
+      moduleCount,
+      totalSize,
+      lastUpdate: db.lastUpdate,
+      sharedPath: SHARED_MODULES,
+    };
+  }
+
+  async runNpmInstall(cwd) {
+    return new Promise((resolve, reject) => {
+      const child = spawn('npm', ['install', '--ignore-scripts', '--no-audit', '--no-fund'], {
+        cwd,
+        stdio: 'pipe',
+        shell: false,
+      });
+
+      child.on('close', (code) => {
+        if (code === 0) resolve();
+        else reject(new Error('npm install failed'));
+      });
+
+      child.on('error', reject);
+    });
+  }
+
+  getSharedModulesPath() {
+    return SHARED_MODULES;
+  }
+
+  getNodeModulesPaths() {
+    return [
+      SHARED_MODULES,
+      path.join(process.cwd(), 'node_modules'),
+    ];
+  }
+
+  async linkFromLocal() {
+    await this.init();
+    const localNodeModules = path.join(process.cwd(), 'node_modules');
+    const db = await this.getModulesDb();
+    const results = { linked: 0, skipped: 0 };
+
+    if (!(await fs.pathExists(localNodeModules))) {
+      logger.warning('No local node_modules found');
+      return results;
+    }
+
+    logger.info('Linking local modules to shared folder...');
+
+    const items = await fs.readdir(localNodeModules);
+    for (const item of items) {
+      // Skip hidden files and .bin
+      if (item.startsWith('.') || item === '.bin') continue;
+
+      const localPath = path.join(localNodeModules, item);
+      const sharedPath = path.join(SHARED_MODULES, item);
+
+      try {
+        const stat = await fs.lstat(localPath);
+        if (!stat.isDirectory()) continue;
+
+        // Check if already in shared
+        if (await fs.pathExists(sharedPath)) {
+          results.skipped++;
+          continue;
+        }
+
+        // Read package.json to get version
+        const pkgPath = path.join(localPath, 'package.json');
+        let version = '*';
+        if (await fs.pathExists(pkgPath)) {
+          const pkg = await fs.readJson(pkgPath);
+          version = pkg.version || '*';
+        }
+
+        // Copy to shared folder
+        await fs.copy(localPath, sharedPath);
+
+        // Update database
+        const moduleKey = `${item}@${version}`;
+        db.modules[moduleKey] = {
+          name: item,
+          version,
+          installedAt: new Date().toISOString(),
+          path: sharedPath,
+          linkedFromLocal: true,
+        };
+
+        results.linked++;
+        logger.dim(`  Linked ${item}@${version}`);
+      } catch (e) {
+        // Skip modules that can't be read
+      }
+    }
+
+    await this.saveModulesDb(db);
+    return results;
+  }
+}
+
+module.exports = new SharedModules();