@openagents-org/agent-connector 0.2.8 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagents-org/agent-connector",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "description": "Agent management CLI and library for OpenAgents — install, configure, and run AI coding agents",
   "main": "src/index.js",
   "bin": {

package/src/installer.js

@@ -84,16 +84,80 @@ class Installer {
       throw new Error(`No install definition for agent type: ${agentType}`);
     }
 
-    const cmd = this._getInstallCommand(entry.install);
+    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()}`);
+    }
+
+    // Resolve npm to use bundled node if system npm is not available
+    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}>}
@@ -115,6 +179,60 @@ class Installer {
     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.
    */
@@ -223,30 +341,81 @@ class Installer {
     } catch {}
   }
 
-  // -- Shell exec --
+  // -- Shell env + exec --
+
+  _buildShellEnv() {
+    const env = { ...process.env };
+    const sep = process.platform === 'win32' ? ';' : ':';
+    const extraDirs = [];
+    try { extraDirs.push(path.dirname(process.execPath)); } catch {}
+    if (process.platform === 'win32') {
+      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;
+  }
+
+  /**
+   * Resolve the npm CLI path. Prefers system npm, falls back to Electron's
+   * bundled node + npm-cli.js so installs work on machines without Node.js.
+   */
+  _resolveNpmCommand(args) {
+    // 1. Try system npm
+    const { whichBinary } = require('./paths');
+    const systemNpm = whichBinary('npm');
+    if (systemNpm) return `npm ${args}`;
+
+    // 2. Use Electron's bundled node to run npm-cli.js
+    const nodeExe = process.execPath;
+    // Look for npm-cli.js relative to the node binary
+    const candidates = [
+      // Electron on Windows: resources/app/node_modules/npm/bin/npm-cli.js
+      path.join(path.dirname(nodeExe), 'resources', 'app', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+      // npm installed alongside node
+      path.join(path.dirname(nodeExe), '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+      path.join(path.dirname(nodeExe), 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    ];
+    // Also check if npm is available as a module from the current process
+    try {
+      const npmCliPath = require.resolve('npm/bin/npm-cli.js');
+      if (npmCliPath) candidates.unshift(npmCliPath);
+    } catch {}
+
+    for (const p of candidates) {
+      try {
+        if (fs.existsSync(p)) {
+          return `"${nodeExe}" "${p}" ${args}`;
+        }
+      } catch {}
+    }
+
+    // 3. Last resort: just try npm and hope for the best
+    return `npm ${args}`;
+  }
 
   _execShell(cmd, timeoutMs = 300000) {
     return new Promise((resolve, reject) => {
-      const env = getEnhancedEnv();
-      // Also include Electron's own binary dir
-      const execDir = path.dirname(process.execPath);
-      if (execDir && !(env.PATH || '').includes(execDir)) {
-        const sep = process.platform === 'win32' ? ';' : ':';
-        env.PATH = execDir + sep + (env.PATH || '');
-      }
+      const env = this._buildShellEnv();
 
-      // On Windows, use cmd.exe explicitly with UTF-8 codepage
-      let shellCmd = cmd;
-      let shellOpt = true;
+      let shell = true;
       if (process.platform === 'win32') {
-        shellCmd = `cmd.exe /C "chcp 65001 >nul & ${cmd}"`;
-        shellOpt = false; // we're specifying the shell ourselves
+        shell = env.ComSpec || 'C:\\Windows\\System32\\cmd.exe';
       }
 
-      exec(shellCmd, {
+      exec(cmd, {
         encoding: 'utf-8',
         timeout: timeoutMs,
-        shell: shellOpt,
+        shell,
         env,
       }, (error, stdout, stderr) => {
         const output = ((stdout || '') + '\n' + (stderr || '')).trim();

package/src/paths.js

@@ -36,11 +36,19 @@ function getExtraBinDirs() {
   // Common: ~/.local/bin (pipx, user installs)
   _push(dirs, path.join(HOME, '.local', 'bin'));
 
+  // Also add the directory containing the current node binary
+  try {
+    const nodeDir = path.dirname(process.execPath);
+    if (nodeDir) _push(dirs, nodeDir);
+  } catch {}
+
   // Filter to existing directories only, deduplicate
   const seen = new Set();
   const currentPATH = process.env.PATH || '';
   return dirs.filter(d => {
-    if (!d || seen.has(d) || currentPATH.includes(d)) return false;
+    if (!d || seen.has(d)) return false;
+    // Skip if already in PATH (case-insensitive on Windows)
+    if (IS_WINDOWS ? currentPATH.toLowerCase().includes(d.toLowerCase()) : currentPATH.includes(d)) return false;
     seen.add(d);
     try {
       return fs.statSync(d).isDirectory();
@@ -71,10 +79,14 @@ function getEnhancedEnv(baseEnv) {
   }
   if (IS_WINDOWS) {
     // Force UTF-8 output from child processes on non-English Windows locales
-    // (prevents GBK/Shift-JIS garbled text in error messages)
     env.PYTHONIOENCODING = env.PYTHONIOENCODING || 'utf-8';
     env.PYTHONUTF8 = env.PYTHONUTF8 || '1';
     env.LANG = env.LANG || 'en_US.UTF-8';
+    // Ensure ComSpec points to cmd.exe (Electron may not set it)
+    if (!env.ComSpec) {
+      const sysRoot = env.SystemRoot || 'C:\\Windows';
+      env.ComSpec = path.join(sysRoot, 'System32', 'cmd.exe');
+    }
   }
   return env;
 }
@@ -104,6 +116,10 @@ function _addWindowsPaths(dirs) {
   const appData = process.env.APPDATA || '';
   const localAppData = process.env.LOCALAPPDATA || '';
   const programFiles = process.env.ProgramFiles || 'C:\\Program Files';
+  const sysRoot = process.env.SystemRoot || 'C:\\Windows';
+
+  // System32 (cmd.exe, powershell, etc) — Electron may not have it
+  _push(dirs, path.join(sysRoot, 'System32'));
 
   // npm global bin
   if (appData) _push(dirs, path.join(appData, 'npm'));