nodepyx 1.0.0

package/src/env/CondaManager.ts

@@ -0,0 +1,451 @@
+/**
+ * nodepyx — CondaManager
+ * Manages Conda environments for Python package isolation.
+ *
+ * Supports:
+ *   - Detecting an existing conda environment by name
+ *   - Creating new conda environments
+ *   - Installing packages into a conda environment (conda + pip fallback)
+ *   - Returning the Python executable path inside a conda env
+ *
+ * Detection order for conda executable:
+ *   1. CONDA_EXE environment variable
+ *   2. MAMBA_EXE (uses mamba as a drop-in replacement)
+ *   3. condaPath from config
+ *   4. 'conda' on PATH
+ *   5. Common installation locations
+ */
+
+import { execSync, spawnSync } from 'child_process';
+import * as fs   from 'fs';
+import * as path from 'path';
+import * as os   from 'os';
+import { Logger } from '../utils/Logger';
+import type { CondaConfig } from '../types/config';
+
+const logger = new Logger('CondaManager');
+
+// ─── Types ─────────────────────────────────────────────────────────────────
+
+export interface CondaEnvInfo {
+  /** Environment name */
+  name: string;
+  /** Absolute prefix path of the environment */
+  prefix: string;
+  /** Python executable inside the env */
+  pythonExecutable: string;
+  /** Whether this is the currently active environment */
+  isActive: boolean;
+}
+
+export interface CondaSetupResult {
+  /** Absolute path to Python executable */
+  pythonExecutable: string;
+  /** Whether the env was newly created */
+  created: boolean;
+  /** Whether packages were installed */
+  packagesInstalled: boolean;
+  /** Environment info */
+  envInfo: CondaEnvInfo;
+}
+
+export interface CondaManagerOptions {
+  /** Conda config from nodepyxConfig */
+  conda: CondaConfig;
+  /** Timeout for conda operations (ms). Default: 300000 (5 min) */
+  timeout?: number;
+  /** Use mamba instead of conda if available. Default: true */
+  preferMamba?: boolean;
+}
+
+// ─── Common conda installation paths ─────────────────────────────────────────
+
+const CONDA_LOCATIONS_LINUX = [
+  '/opt/conda/bin/conda',
+  `${os.homedir()}/anaconda3/bin/conda`,
+  `${os.homedir()}/miniconda3/bin/conda`,
+  `${os.homedir()}/miniconda/bin/conda`,
+  '/usr/local/bin/conda',
+];
+
+const CONDA_LOCATIONS_DARWIN = [
+  `${os.homedir()}/opt/anaconda3/bin/conda`,
+  `${os.homedir()}/opt/miniconda3/bin/conda`,
+  '/opt/homebrew/bin/conda',
+  `/opt/conda/bin/conda`,
+];
+
+const CONDA_LOCATIONS_WIN = [
+  `${process.env.USERPROFILE}\\Anaconda3\\Scripts\\conda.exe`,
+  `${process.env.USERPROFILE}\\Miniconda3\\Scripts\\conda.exe`,
+  `C:\\Anaconda3\\Scripts\\conda.exe`,
+  `C:\\Miniconda3\\Scripts\\conda.exe`,
+  `${process.env.PROGRAMDATA}\\Anaconda3\\Scripts\\conda.exe`,
+];
+
+/**
+ * CondaManager — manages Conda environments.
+ *
+ * @example
+ * ```typescript
+ * const manager = new CondaManager({
+ *   conda: {
+ *     envName: 'my-ml-env',
+ *     packages: ['numpy', 'pandas', 'scikit-learn'],
+ *     channels: ['conda-forge', 'defaults'],
+ *   }
+ * });
+ *
+ * const result = await manager.setup();
+ * console.log(result.pythonExecutable);  // /opt/conda/envs/my-ml-env/bin/python3
+ * ```
+ */
+export class CondaManager {
+  private readonly _config: CondaConfig;
+  private readonly _timeout: number;
+  private readonly _preferMamba: boolean;
+  private _condaExec: string | null = null;
+
+  constructor(options: CondaManagerOptions) {
+    this._config       = options.conda;
+    this._timeout      = options.timeout      ?? 300_000;
+    this._preferMamba  = options.preferMamba  ?? true;
+  }
+
+  // ─── Public API ──────────────────────────────────────────────────────────
+
+  /**
+   * Set up the Conda environment.
+   * Creates the environment if it doesn't exist, then installs packages.
+   */
+  async setup(): Promise<CondaSetupResult> {
+    const condaExec = this._findCondaExecutable();
+    if (!condaExec) {
+      throw new CondaNotFoundError(
+        'Could not find conda executable. ' +
+        'Install Anaconda/Miniconda or set CONDA_EXE environment variable.',
+      );
+    }
+
+    this._condaExec = condaExec;
+    logger.info(`CondaManager: using conda at ${condaExec}`);
+
+    let created = false;
+    let packagesInstalled = false;
+
+    // ── Check if environment exists ──────────────────────────────────────
+    const existingEnv = await this._findEnv(this._config.envName);
+
+    if (!existingEnv) {
+      logger.info(`CondaManager: creating environment '${this._config.envName}'`);
+      await this._createEnv();
+      created = true;
+    }
+
+    const envInfo = await this._getEnvInfo(this._config.envName);
+    if (!envInfo) {
+      throw new CondaEnvError(`Environment '${this._config.envName}' not found after creation`);
+    }
+
+    // ── Install packages ─────────────────────────────────────────────────
+    const packagesToInstall = this._config.packages ?? [];
+    if (packagesToInstall.length > 0) {
+      logger.info(`CondaManager: installing packages into '${this._config.envName}'`);
+      await this._installPackages(envInfo.prefix, packagesToInstall);
+      packagesInstalled = true;
+    }
+
+    return {
+      pythonExecutable: envInfo.pythonExecutable,
+      created,
+      packagesInstalled,
+      envInfo,
+    };
+  }
+
+  /**
+   * List all conda environments.
+   */
+  async listEnvironments(): Promise<CondaEnvInfo[]> {
+    const conda = this._findCondaExecutable();
+    if (!conda) {return [];}
+
+    try {
+      const result = spawnSync(
+        conda,
+        ['env', 'list', '--json'],
+        { encoding: 'utf8', timeout: 30_000, stdio: 'pipe' },
+      );
+
+      if (result.status !== 0) {return [];}
+
+      const parsed = JSON.parse(result.stdout) as { envs: string[] };
+      const envs: CondaEnvInfo[] = [];
+
+      for (const prefix of parsed.envs ?? []) {
+        const name = path.basename(prefix);
+        const pyExec = this._pythonInPrefix(prefix);
+        if (fs.existsSync(pyExec)) {
+          envs.push({
+            name,
+            prefix,
+            pythonExecutable: pyExec,
+            isActive: process.env.CONDA_PREFIX === prefix,
+          });
+        }
+      }
+
+      return envs;
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Check if a conda environment exists.
+   */
+  async environmentExists(envName: string): Promise<boolean> {
+    return (await this._findEnv(envName)) !== null;
+  }
+
+  /**
+   * Get the Python executable for a conda environment.
+   */
+  async getPythonExecutable(envName: string): Promise<string | null> {
+    const info = await this._getEnvInfo(envName);
+    return info?.pythonExecutable ?? null;
+  }
+
+  /**
+   * Install packages into an existing environment.
+   */
+  async installPackages(envName: string, packages: string[]): Promise<void> {
+    const info = await this._getEnvInfo(envName);
+    if (!info) {
+      throw new CondaEnvError(`Environment '${envName}' not found`);
+    }
+    await this._installPackages(info.prefix, packages);
+  }
+
+  /**
+   * Remove a conda environment.
+   */
+  async removeEnvironment(envName: string): Promise<void> {
+    const conda = this._ensureCondaExec();
+    const result = spawnSync(
+      conda,
+      ['env', 'remove', '--name', envName, '--yes'],
+      { encoding: 'utf8', timeout: 120_000, stdio: 'pipe' },
+    );
+
+    if (result.status !== 0) {
+      logger.warn(`CondaManager: failed to remove env '${envName}'`);
+    } else {
+      logger.info(`CondaManager: removed environment '${envName}'`);
+    }
+  }
+
+  /**
+   * Return the conda executable path (or null if not found).
+   */
+  get condaExecutable(): string | null {
+    return this._findCondaExecutable();
+  }
+
+  // ─── Private ─────────────────────────────────────────────────────────────
+
+  private _findCondaExecutable(): string | null {
+    // mamba is a faster drop-in
+    if (this._preferMamba) {
+      const mamba = process.env.MAMBA_EXE || this._which('mamba');
+      if (mamba) {return mamba;}
+    }
+
+    // CONDA_EXE env var
+    if (process.env.CONDA_EXE) {return process.env.CONDA_EXE;}
+
+    // Explicit config path
+    if (this._config.condaPath) {return this._config.condaPath;}
+
+    // PATH
+    const fromPath = this._which('conda');
+    if (fromPath) {return fromPath;}
+
+    // Common locations
+    const locations =
+      process.platform === 'win32'   ? CONDA_LOCATIONS_WIN   :
+      process.platform === 'darwin'  ? CONDA_LOCATIONS_DARWIN :
+                                       CONDA_LOCATIONS_LINUX;
+
+    for (const loc of locations) {
+      if (loc && fs.existsSync(loc)) {return loc;}
+    }
+
+    return null;
+  }
+
+  private _ensureCondaExec(): string {
+    const exec = this._condaExec ?? this._findCondaExecutable();
+    if (!exec) {throw new CondaNotFoundError('conda executable not found');}
+    return exec;
+  }
+
+  private async _findEnv(envName: string): Promise<string | null> {
+    try {
+      const envs = await this.listEnvironments();
+      const match = envs.find(e => e.name === envName);
+      return match?.prefix ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  private async _getEnvInfo(envName: string): Promise<CondaEnvInfo | null> {
+    try {
+      const envs = await this.listEnvironments();
+      return envs.find(e => e.name === envName) ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  private async _createEnv(): Promise<void> {
+    const conda = this._ensureCondaExec();
+    const args = [
+      'create',
+      '--name', this._config.envName,
+      '--yes',
+      'python>=3.8',
+      '--quiet',
+    ];
+
+    if (this._config.channels?.length) {
+      for (const ch of this._config.channels) {
+        args.push('--channel', ch);
+      }
+    }
+
+    const result = spawnSync(conda, args, {
+      encoding:  'utf8',
+      timeout:   this._timeout,
+      stdio:     ['ignore', 'pipe', 'pipe'],
+    });
+
+    if (result.status !== 0) {
+      const err = result.stderr?.trim() || 'conda create failed';
+      throw new CondaEnvError(`Failed to create conda env '${this._config.envName}': ${err}`);
+    }
+
+    logger.info(`CondaManager: created env '${this._config.envName}'`);
+  }
+
+  private async _installPackages(prefix: string, packages: string[]): Promise<void> {
+    if (packages.length === 0) {return;}
+
+    const conda = this._ensureCondaExec();
+
+    // Split into conda-installable and pip-only packages
+    const pipOnlyMarker = 'pip::';
+    const condaPackages = packages.filter(p => !p.startsWith(pipOnlyMarker));
+    const pipPackages   = packages.filter(p => p.startsWith(pipOnlyMarker)).map(p => p.slice(pipOnlyMarker.length));
+
+    // conda install
+    if (condaPackages.length > 0) {
+      const condaArgs = [
+        'install',
+        '--prefix', prefix,
+        '--yes',
+        '--quiet',
+        ...condaPackages,
+      ];
+
+      if (this._config.channels?.length) {
+        for (const ch of this._config.channels) {
+          condaArgs.push('--channel', ch);
+        }
+      }
+
+      const result = spawnSync(conda, condaArgs, {
+        encoding:  'utf8',
+        timeout:   this._timeout,
+        stdio:     ['ignore', 'pipe', 'pipe'],
+      });
+
+      if (result.status !== 0) {
+        // Fall back to pip for failed packages
+        logger.warn(`CondaManager: conda install failed, falling back to pip`);
+        pipPackages.push(...condaPackages);
+      } else {
+        logger.info(`CondaManager: conda-installed ${condaPackages.join(', ')}`);
+      }
+    }
+
+    // pip install (fallback)
+    if (pipPackages.length > 0) {
+      const pip = path.join(
+        prefix,
+        process.platform === 'win32' ? 'Scripts\\pip.exe' : 'bin/pip3',
+      );
+
+      if (!fs.existsSync(pip)) {
+        logger.warn(`CondaManager: pip not found in env, skipping: ${pipPackages.join(', ')}`);
+        return;
+      }
+
+      const result = spawnSync(pip, ['install', '--quiet', ...pipPackages], {
+        encoding:  'utf8',
+        timeout:   this._timeout,
+        stdio:     ['ignore', 'pipe', 'pipe'],
+      });
+
+      if (result.status !== 0) {
+        throw new CondaPackageInstallError(pipPackages, result.stderr?.trim() ?? 'unknown error');
+      }
+
+      logger.info(`CondaManager: pip-installed ${pipPackages.join(', ')}`);
+    }
+  }
+
+  private _pythonInPrefix(prefix: string): string {
+    return path.join(
+      prefix,
+      process.platform === 'win32' ? 'python.exe' : 'bin/python3',
+    );
+  }
+
+  private _which(name: string): string | null {
+    try {
+      const cmd = process.platform === 'win32' ? `where ${name}` : `which ${name}`;
+      const result = execSync(cmd, { encoding: 'utf8', timeout: 3000, stdio: 'pipe' }).trim();
+      return result.split(/\r?\n/)[0]?.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+}
+
+// ─── Error types ─────────────────────────────────────────────────────────────
+
+export class CondaNotFoundError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'CondaNotFoundError';
+  }
+}
+
+export class CondaEnvError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'CondaEnvError';
+  }
+}
+
+export class CondaPackageInstallError extends Error {
+  readonly packages: string[];
+  constructor(packages: string[], detail: string) {
+    super(`Failed to install conda packages [${packages.join(', ')}]: ${detail}`);
+    this.name    = 'CondaPackageInstallError';
+    this.packages = packages;
+  }
+}
+