@openagents-org/agent-launcher 0.1.0

package/src/installer.js

@@ -0,0 +1,588 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, exec } = require('child_process');
+const { whichBinary, getEnhancedEnv } = require('./paths');
+
+/**
+ * Manages installation and uninstallation of agent runtimes.
+ *
+ * Install markers are stored in two places for compatibility with the Python SDK:
+ *   1. ~/.openagents/installed_agents.json  (JSON array of names)
+ *   2. ~/.openagents/installed/<name>       (empty marker files)
+ */
+class Installer {
+  constructor(registry, configDir) {
+    this.registry = registry;
+    this.configDir = configDir;
+    this.markersFile = path.join(configDir, 'installed_agents.json');
+    this.markersDir = path.join(configDir, 'installed');
+  }
+
+  /**
+   * Get the current platform key: 'macos', 'linux', or 'windows'.
+   */
+  static platform() {
+    const p = process.platform;
+    if (p === 'darwin') return 'macos';
+    if (p === 'win32') return 'windows';
+    return 'linux';
+  }
+
+  /**
+   * Check if an agent type is installed.
+   * Checks binary on PATH first, then marker files.
+   */
+  isInstalled(agentType) {
+    if (this._whichBinary(agentType)) return true;
+    return this._hasMarker(agentType);
+  }
+
+  /**
+   * Find the binary path for an agent type.
+   */
+  which(agentType) {
+    return this._whichBinary(agentType);
+  }
+
+  /**
+   * Health check — binary existence + version.
+   * @returns {{ installed: boolean, binary: string|null, version: string|null }}
+   */
+  healthCheck(agentType) {
+    const binary = this._whichBinary(agentType);
+    if (!binary) return { installed: false, binary: null, version: null };
+
+    const entry = this.registry.getEntry(agentType);
+    const checkCmd = entry && entry.install ? entry.install.check_command : null;
+    const versionCmd = checkCmd || `${entry && entry.install && entry.install.binary || agentType} --version`;
+
+    let version = null;
+    try {
+      const raw = execSync(versionCmd, {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: getEnhancedEnv(),
+        timeout: 10000,
+      }).trim();
+      // Extract version number (e.g. "openclaw 2024.1.5" → "2024.1.5")
+      const match = raw.match(/(\d+[\d.]+\d+)/);
+      version = match ? match[1] : raw.split('\n')[0];
+    } catch {}
+
+    return { installed: true, binary, version };
+  }
+
+  /**
+   * Install an agent runtime.
+   * @returns {Promise<{success: boolean, output: string}>}
+   */
+  async install(agentType) {
+    const entry = this.registry.getEntry(agentType);
+    if (!entry || !entry.install) {
+      throw new Error(`No install definition for agent type: ${agentType}`);
+    }
+
+    let cmd = this._getInstallCommand(entry.install);
+    if (!cmd) {
+      throw new Error(`No install command for ${agentType} on ${Installer.platform()}`);
+    }
+
+    // Use bundled node/npm if system npm not available
+    if (cmd.startsWith('npm install')) {
+      const args = cmd.replace('npm install', 'install');
+      cmd = this._resolveNpmCommand(args);
+    }
+
+    const output = await this._execShell(cmd);
+    this._markInstalled(agentType);
+    return { success: true, output };
+  }
+
+  /**
+   * Install with streaming output via callback.
+   * @param {string} agentType
+   * @param {function(string)} onData - called with each chunk of output
+   * @returns {Promise<{success: boolean, command: string}>}
+   */
+  async installStreaming(agentType, onData) {
+    const { spawn } = require('child_process');
+    const entry = this.registry.getEntry(agentType);
+    if (!entry || !entry.install) {
+      throw new Error(`No install definition for agent type: ${agentType}`);
+    }
+
+    let rawCmd = this._getInstallCommand(entry.install);
+    if (!rawCmd) {
+      throw new Error(`No install command for ${agentType} on ${Installer.platform()}`);
+    }
+
+    // Auto-install Node.js if this is an npm-based agent and Node.js is missing
+    if (rawCmd.startsWith('npm install') && !this.hasNodejs()) {
+      await this.installNodejs(onData);
+    }
+
+    // Resolve npm command
+    let cmd = rawCmd;
+    if (rawCmd.startsWith('npm install')) {
+      const args = rawCmd.replace('npm install', 'install --loglevel=verbose');
+      cmd = this._resolveNpmCommand(args);
+    } else if (rawCmd.startsWith('pip install') || rawCmd.startsWith('pipx install')) {
+      cmd = rawCmd; // pip commands stay as-is
+    }
+
+    if (onData) onData(`$ ${cmd}\n\n`);
+
+    const env = this._buildShellEnv();
+    const shell = process.platform === 'win32'
+      ? (process.env.ComSpec || 'C:\\Windows\\System32\\cmd.exe')
+      : true;
+
+    return new Promise((resolve, reject) => {
+      const proc = spawn(cmd, [], { shell, env, stdio: ['ignore', 'pipe', 'pipe'] });
+
+      if (proc.stdout) proc.stdout.setEncoding('utf-8');
+      if (proc.stderr) proc.stderr.setEncoding('utf-8');
+
+      if (proc.stdout) proc.stdout.on('data', (d) => { if (onData) onData(d); });
+      if (proc.stderr) proc.stderr.on('data', (d) => { if (onData) onData(d); });
+
+      proc.on('error', (err) => reject(err));
+      proc.on('close', (code) => {
+        if (code === 0) {
+          this._markInstalled(agentType);
+          if (onData) onData(`\nDone! ${agentType} is now installed.\n`);
+          resolve({ success: true, command: cmd });
+        } else {
+          const msg = `Install failed with exit code ${code}`;
+          if (onData) onData(`\n${msg}\n`);
+          reject(new Error(msg));
+        }
+      });
+    });
+  }
+
+  /**
+   * Uninstall an agent runtime.
+   * @returns {Promise<{success: boolean, output: string}>}
+   */
+  async uninstall(agentType) {
+    const entry = this.registry.getEntry(agentType);
+    if (!entry || !entry.install) {
+      throw new Error(`No install definition for agent type: ${agentType}`);
+    }
+
+    const installCmd = this._getInstallCommand(entry.install);
+    const uninstallCmd = this._deriveUninstallCommand(installCmd);
+    if (!uninstallCmd) {
+      throw new Error(`Cannot derive uninstall command for ${agentType}`);
+    }
+
+    const output = await this._execShell(uninstallCmd);
+    this._markUninstalled(agentType);
+    return { success: true, output };
+  }
+
+  /**
+   * Uninstall with streaming output via callback.
+   */
+  async uninstallStreaming(agentType, onData) {
+    const { spawn } = require('child_process');
+    const entry = this.registry.getEntry(agentType);
+    if (!entry || !entry.install) {
+      throw new Error(`No install definition for agent type: ${agentType}`);
+    }
+
+    const installCmd = this._getInstallCommand(entry.install);
+    let rawCmd = this._deriveUninstallCommand(installCmd);
+    if (!rawCmd) {
+      throw new Error(`Cannot derive uninstall command for ${agentType}`);
+    }
+
+    // Resolve npm to use bundled node if system npm is not available
+    let cmd = rawCmd;
+    if (rawCmd.startsWith('npm uninstall')) {
+      const args = rawCmd.replace('npm uninstall', 'uninstall --loglevel=verbose');
+      cmd = this._resolveNpmCommand(args);
+    }
+
+    if (onData) onData(`$ ${cmd}\n\n`);
+
+    const env = this._buildShellEnv();
+    const shell = process.platform === 'win32'
+      ? (process.env.ComSpec || 'C:\\Windows\\System32\\cmd.exe')
+      : true;
+
+    return new Promise((resolve, reject) => {
+      const proc = spawn(cmd, [], { shell, env, stdio: ['ignore', 'pipe', 'pipe'] });
+
+      if (proc.stdout) proc.stdout.setEncoding('utf-8');
+      if (proc.stderr) proc.stderr.setEncoding('utf-8');
+
+      if (proc.stdout) proc.stdout.on('data', (d) => { if (onData) onData(d); });
+      if (proc.stderr) proc.stderr.on('data', (d) => { if (onData) onData(d); });
+
+      proc.on('error', (err) => reject(err));
+      proc.on('close', (code) => {
+        if (code === 0) {
+          this._markUninstalled(agentType);
+          if (onData) onData(`\nDone! ${agentType} has been uninstalled.\n`);
+          resolve({ success: true, command: cmd });
+        } else {
+          const msg = `Uninstall failed with exit code ${code}`;
+          if (onData) onData(`\n${msg}\n`);
+          reject(new Error(msg));
+        }
+      });
+    });
+  }
+
+  /**
+   * Get install command for current platform.
+   */
+  _getInstallCommand(installCfg) {
+    const plat = Installer.platform();
+    return installCfg[plat] || installCfg.command || null;
+  }
+
+  /**
+   * Derive uninstall command from install command.
+   */
+  _deriveUninstallCommand(installCmd) {
+    if (!installCmd) return null;
+
+    // npm install -g <pkg> → npm uninstall -g <pkg>
+    if (installCmd.includes('npm install')) {
+      return installCmd
+        .replace('npm install -g', 'npm uninstall -g')
+        .replace('npm install', 'npm uninstall')
+        .replace(/@latest/g, '')
+        .replace(/@[\d.]+/g, '');
+    }
+
+    // pip install <pkg> → pip uninstall -y <pkg>
+    if (installCmd.includes('pip install') || installCmd.includes('pip3 install')) {
+      return installCmd
+        .replace('pip install', 'pip uninstall -y')
+        .replace('pip3 install', 'pip3 uninstall -y');
+    }
+
+    // pipx install <pkg> → pipx uninstall <pkg>
+    if (installCmd.includes('pipx install')) {
+      return installCmd.replace('pipx install', 'pipx uninstall');
+    }
+
+    return null;
+  }
+
+  /**
+   * Find a binary on PATH (delegates to paths.js for cross-platform detection).
+   */
+  _whichBinary(agentType) {
+    const entry = this.registry.getEntry(agentType);
+    const binary = entry && entry.install ? entry.install.binary : agentType;
+    return whichBinary(binary);
+  }
+
+  // -- Markers --
+
+  _hasMarker(agentType) {
+    // Check per-agent marker file first (faster)
+    try {
+      if (fs.existsSync(path.join(this.markersDir, agentType))) return true;
+    } catch {}
+
+    // Check JSON markers file
+    try {
+      if (fs.existsSync(this.markersFile)) {
+        const data = JSON.parse(fs.readFileSync(this.markersFile, 'utf-8'));
+        if (Array.isArray(data) && data.includes(agentType)) return true;
+      }
+    } catch {}
+
+    return false;
+  }
+
+  _markInstalled(agentType) {
+    // JSON file
+    try {
+      fs.mkdirSync(this.configDir, { recursive: true });
+      let markers = [];
+      try {
+        markers = JSON.parse(fs.readFileSync(this.markersFile, 'utf-8'));
+        if (!Array.isArray(markers)) markers = [];
+      } catch {}
+      if (!markers.includes(agentType)) {
+        markers.push(agentType);
+        markers.sort();
+      }
+      fs.writeFileSync(this.markersFile, JSON.stringify(markers), 'utf-8');
+    } catch {}
+
+    // Per-agent marker file
+    try {
+      fs.mkdirSync(this.markersDir, { recursive: true });
+      fs.writeFileSync(path.join(this.markersDir, agentType), '', 'utf-8');
+    } catch {}
+  }
+
+  _markUninstalled(agentType) {
+    // JSON file
+    try {
+      if (fs.existsSync(this.markersFile)) {
+        let markers = JSON.parse(fs.readFileSync(this.markersFile, 'utf-8'));
+        if (Array.isArray(markers)) {
+          markers = markers.filter((m) => m !== agentType);
+          fs.writeFileSync(this.markersFile, JSON.stringify(markers), 'utf-8');
+        }
+      }
+    } catch {}
+
+    // Per-agent marker file
+    try {
+      const markerFile = path.join(this.markersDir, agentType);
+      if (fs.existsSync(markerFile)) fs.unlinkSync(markerFile);
+    } catch {}
+  }
+
+  // -- Shell env + exec --
+
+  _buildShellEnv() {
+    const env = { ...process.env };
+    const sep = process.platform === 'win32' ? ';' : ':';
+    const extraDirs = [];
+    try { extraDirs.push(path.dirname(process.execPath)); } catch {}
+
+    // Check for bundled Node.js in ~/.openagents/nodejs/
+    if (process.platform === 'win32') {
+      try {
+        const bundledDir = path.join(this.configDir, 'nodejs');
+        if (fs.existsSync(bundledDir)) {
+          const entries = fs.readdirSync(bundledDir).filter(e => e.startsWith('node-'));
+          if (entries.length > 0) {
+            extraDirs.push(path.join(bundledDir, entries[0]));
+          }
+        }
+      } catch {}
+      const appData = env.APPDATA || '';
+      if (appData) extraDirs.push(path.join(appData, 'npm'));
+      extraDirs.push(env.ProgramFiles ? path.join(env.ProgramFiles, 'nodejs') : 'C:\\Program Files\\nodejs');
+      extraDirs.push(env.SystemRoot ? path.join(env.SystemRoot, 'System32') : 'C:\\Windows\\System32');
+      extraDirs.push(env.ProgramFiles ? path.join(env.ProgramFiles, 'Git', 'cmd') : 'C:\\Program Files\\Git\\cmd');
+    } else {
+      extraDirs.push('/usr/local/bin', '/opt/homebrew/bin');
+    }
+    for (const d of extraDirs) {
+      if (d && !(env.PATH || '').includes(d)) {
+        env.PATH = d + sep + (env.PATH || '');
+      }
+    }
+    return env;
+  }
+
+  /**
+   * Check if Node.js/npm is available on the system.
+   */
+  hasNodejs() {
+    if (whichBinary('node') && whichBinary('npm')) return true;
+    // Check bundled Node.js in ~/.openagents/nodejs/
+    if (process.platform === 'win32') {
+      try {
+        const bundledDir = path.join(this.configDir, 'nodejs');
+        if (fs.existsSync(bundledDir)) {
+          const entries = fs.readdirSync(bundledDir).filter(e => e.startsWith('node-'));
+          if (entries.length > 0) {
+            const nodeExe = path.join(bundledDir, entries[0], 'node.exe');
+            return fs.existsSync(nodeExe);
+          }
+        }
+      } catch {}
+    }
+    return false;
+  }
+
+  /**
+   * Download and install Node.js LTS. Streams progress via onData callback.
+   * After install, updates PATH so npm is available for subsequent commands.
+   * @param {function(string)} onData
+   * @returns {Promise<void>}
+   */
+  async installNodejs(onData) {
+    const { spawn: spawnProc } = require('child_process');
+    const https = require('https');
+    const os = require('os');
+    const nodeVersion = 'v22.14.0';
+    const plat = Installer.platform();
+
+    if (onData) onData(`Node.js not found. Installing Node.js ${nodeVersion}...\n\n`);
+
+    if (plat === 'windows') {
+      // Download portable zip — no admin required
+      const arch = os.arch() === 'x64' ? 'x64' : 'x86';
+      const url = `https://nodejs.org/dist/${nodeVersion}/node-${nodeVersion}-win-${arch}.zip`;
+      const zipPath = path.join(os.tmpdir(), `node-${nodeVersion}.zip`);
+
+      if (onData) onData(`Downloading ${url}...\n`);
+      await this._downloadFile(url, zipPath, onData);
+
+      // Extract to ~/.openagents/nodejs/
+      const nodejsDir = path.join(this.configDir, 'nodejs');
+      fs.mkdirSync(nodejsDir, { recursive: true });
+
+      if (onData) onData(`\nExtracting Node.js to ${nodejsDir}...\n`);
+      await new Promise((resolve, reject) => {
+        const proc = spawnProc('powershell', [
+          '-NoProfile', '-Command',
+          `Expand-Archive -Path '${zipPath}' -DestinationPath '${nodejsDir}' -Force`
+        ], { stdio: ['ignore', 'pipe', 'pipe'] });
+        if (proc.stdout) proc.stdout.on('data', (d) => { if (onData) onData(d.toString()); });
+        if (proc.stderr) proc.stderr.on('data', (d) => { if (onData) onData(d.toString()); });
+        proc.on('error', reject);
+        proc.on('close', (code) => {
+          if (code === 0) resolve();
+          else reject(new Error(`Extraction failed with code ${code}`));
+        });
+      });
+
+      // The zip extracts to node-vX.X.X-win-x64/ subfolder
+      const extractedDir = path.join(nodejsDir, `node-${nodeVersion}-win-${arch}`);
+      const sep = ';';
+
+      // Add extracted node dir to PATH for this session
+      if (!(process.env.PATH || '').includes(extractedDir)) {
+        process.env.PATH = extractedDir + sep + (process.env.PATH || '');
+      }
+      // npm global installs go to %APPDATA%\npm
+      const npmGlobal = path.join(process.env.APPDATA || '', 'npm');
+      if (npmGlobal && !(process.env.PATH || '').includes(npmGlobal)) {
+        process.env.PATH = npmGlobal + sep + process.env.PATH;
+      }
+
+    } else {
+      // macOS / Linux: download portable tar.gz/tar.xz, extract to ~/.openagents/nodejs/
+      const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
+      const ext = plat === 'macos' ? 'tar.gz' : 'tar.xz';
+      const platName = plat === 'macos' ? 'darwin' : 'linux';
+      const url = `https://nodejs.org/dist/${nodeVersion}/node-${nodeVersion}-${platName}-${arch}.${ext}`;
+      const tarPath = path.join(os.tmpdir(), `node-${nodeVersion}.${ext}`);
+
+      if (onData) onData(`Downloading ${url}...\n`);
+      await this._downloadFile(url, tarPath, onData);
+
+      const nodeDir = path.join(this.configDir, 'nodejs');
+      fs.mkdirSync(nodeDir, { recursive: true });
+
+      if (onData) onData(`\nExtracting to ${nodeDir}...\n`);
+      const tarFlag = ext === 'tar.gz' ? '-xzf' : '-xJf';
+      await new Promise((resolve, reject) => {
+        const proc = spawnProc('tar', [tarFlag, tarPath, '-C', nodeDir, '--strip-components=1'], {
+          stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        if (proc.stdout) proc.stdout.on('data', (d) => { if (onData) onData(d.toString()); });
+        if (proc.stderr) proc.stderr.on('data', (d) => { if (onData) onData(d.toString()); });
+        proc.on('error', reject);
+        proc.on('close', (code) => {
+          if (code === 0) resolve();
+          else reject(new Error(`Extraction failed with code ${code}`));
+        });
+      });
+
+      // Add portable node bin to PATH
+      const nodeBin = path.join(nodeDir, 'bin');
+      if (!(process.env.PATH || '').includes(nodeBin)) {
+        process.env.PATH = nodeBin + ':' + (process.env.PATH || '');
+      }
+    }
+
+    if (onData) onData(`\nNode.js ${nodeVersion} installed successfully.\n\n`);
+  }
+
+  /**
+   * Download a file with progress reporting.
+   */
+  _downloadFile(url, destPath, onData) {
+    const https = require('https');
+    const http = require('http');
+    return new Promise((resolve, reject) => {
+      const get = url.startsWith('https') ? https.get : http.get;
+      get(url, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          // Follow redirect
+          return this._downloadFile(res.headers.location, destPath, onData).then(resolve, reject);
+        }
+        if (res.statusCode !== 200) {
+          return reject(new Error(`Download failed: HTTP ${res.statusCode}`));
+        }
+        const totalBytes = parseInt(res.headers['content-length'] || '0', 10);
+        let downloaded = 0;
+        let lastPercent = -1;
+        const file = fs.createWriteStream(destPath);
+        res.on('data', (chunk) => {
+          downloaded += chunk.length;
+          if (totalBytes > 0) {
+            const pct = Math.floor((downloaded / totalBytes) * 100);
+            if (pct !== lastPercent && pct % 10 === 0) {
+              lastPercent = pct;
+              if (onData) onData(`  ${pct}% (${(downloaded / 1024 / 1024).toFixed(1)} MB)\n`);
+            }
+          }
+        });
+        res.pipe(file);
+        file.on('finish', () => { file.close(); resolve(); });
+        file.on('error', reject);
+      }).on('error', reject);
+    });
+  }
+
+  /**
+   * Resolve the npm CLI command. Uses system npm if available.
+   */
+  _resolveNpmCommand(args) {
+    const systemNpm = whichBinary('npm');
+    const npmBin = systemNpm ? `"${systemNpm}"` : 'npm';
+
+    // On macOS/Linux, use a user-writable prefix to avoid sudo for global installs
+    if (process.platform !== 'win32' && args.includes('-g')) {
+      const globalDir = path.join(this.configDir, 'npm-global');
+      fs.mkdirSync(globalDir, { recursive: true });
+      // Add the bin dir to PATH so installed binaries are found
+      const binDir = path.join(globalDir, 'bin');
+      if (!(process.env.PATH || '').includes(binDir)) {
+        process.env.PATH = binDir + ':' + (process.env.PATH || '');
+      }
+      return `${npmBin} --prefix "${globalDir}" ${args}`;
+    }
+
+    return `${npmBin} ${args}`;
+  }
+
+  _execShell(cmd, timeoutMs = 300000) {
+    return new Promise((resolve, reject) => {
+      const env = this._buildShellEnv();
+
+      let shell = true;
+      if (process.platform === 'win32') {
+        shell = env.ComSpec || 'C:\\Windows\\System32\\cmd.exe';
+      }
+
+      exec(cmd, {
+        encoding: 'utf-8',
+        timeout: timeoutMs,
+        shell,
+        env,
+      }, (error, stdout, stderr) => {
+        const output = ((stdout || '') + '\n' + (stderr || '')).trim();
+        if (error) {
+          const err = new Error(output || error.message);
+          err.exitCode = error.code;
+          reject(err);
+        } else {
+          resolve(output);
+        }
+      });
+    });
+  }
+}
+
+module.exports = { Installer };