@openagents-org/agent-launcher 0.1.0

package/src/paths.js

@@ -0,0 +1,276 @@
+/**
+ * Cross-platform PATH detection.
+ *
+ * Finds binary directories for Node.js version managers (nvm, fnm, volta),
+ * package managers (npm, Homebrew, pip), and standard system locations.
+ * Used by installer.js (binary detection) and daemon.js (agent spawning).
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+const IS_WINDOWS = process.platform === 'win32';
+const IS_MACOS = process.platform === 'darwin';
+const SEP = IS_WINDOWS ? ';' : ':';
+const HOME = process.env.HOME || process.env.USERPROFILE || '';
+
+/**
+ * Get all extra binary directories that should be checked beyond process.env.PATH.
+ * Returns deduplicated list of existing directories.
+ */
+function getExtraBinDirs() {
+  const dirs = [];
+
+  if (IS_WINDOWS) {
+    _addWindowsPaths(dirs);
+  } else {
+    _addUnixPaths(dirs);
+    if (IS_MACOS) {
+      _addMacPaths(dirs);
+    }
+  }
+
+  // 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)) 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();
+    } catch {
+      return false;
+    }
+  });
+}
+
+/**
+ * Build a full PATH string that includes all extra bin dirs prepended.
+ */
+function getEnhancedPATH() {
+  const extra = getExtraBinDirs();
+  const current = process.env.PATH || '';
+  if (extra.length === 0) return current;
+  return extra.join(SEP) + SEP + current;
+}
+
+/**
+ * Build an env object with enhanced PATH for spawning subprocesses.
+ */
+function getEnhancedEnv(baseEnv) {
+  const env = { ...(baseEnv || process.env) };
+  const extra = getExtraBinDirs();
+  if (extra.length > 0) {
+    env.PATH = extra.join(SEP) + SEP + (env.PATH || '');
+  }
+  if (IS_WINDOWS) {
+    // Force UTF-8 output from child processes on non-English Windows locales
+    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;
+}
+
+/**
+ * Find a binary by name. Returns full path or null.
+ */
+function whichBinary(name) {
+  if (!name) return null;
+  const cmd = IS_WINDOWS ? `where ${name}` : `which ${name}`;
+  try {
+    const result = execSync(cmd, {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, PATH: getEnhancedPATH() },
+      timeout: 5000,
+    }).trim();
+    return result.split(/\r?\n/)[0] || null;
+  } catch {
+    return null;
+  }
+}
+
+// ---- Windows paths ----
+
+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'));
+
+  // Node.js install
+  _push(dirs, path.join(programFiles, 'nodejs'));
+
+  // nvm for Windows
+  const nvmHome = process.env.NVM_HOME;
+  if (nvmHome) {
+    _push(dirs, nvmHome);
+    // nvm symlink dir
+    const nvmSymlink = process.env.NVM_SYMLINK || path.join(programFiles, 'nodejs');
+    _push(dirs, nvmSymlink);
+  }
+
+  // fnm
+  if (localAppData) _push(dirs, path.join(localAppData, 'fnm_multishells'));
+  const fnmDir = process.env.FNM_DIR || path.join(appData, 'fnm');
+  if (fnmDir) {
+    // fnm aliases — current version
+    try {
+      const defaultDir = path.join(fnmDir, 'aliases', 'default');
+      if (fs.existsSync(defaultDir)) _push(dirs, defaultDir);
+    } catch {}
+  }
+
+  // volta
+  const voltaHome = process.env.VOLTA_HOME || path.join(localAppData, 'Volta');
+  _push(dirs, path.join(voltaHome, 'bin'));
+
+  // Git (needed for some installers)
+  _push(dirs, path.join(programFiles, 'Git', 'cmd'));
+  _push(dirs, path.join(programFiles, 'Git', 'bin'));
+
+  // Python/pip
+  if (localAppData) {
+    _push(dirs, path.join(localAppData, 'Programs', 'Python', 'Python312', 'Scripts'));
+    _push(dirs, path.join(localAppData, 'Programs', 'Python', 'Python311', 'Scripts'));
+    _push(dirs, path.join(localAppData, 'Programs', 'Python', 'Python310', 'Scripts'));
+  }
+}
+
+// ---- Unix paths ----
+
+function _addUnixPaths(dirs) {
+  // Standard
+  _push(dirs, '/usr/local/bin');
+  _push(dirs, '/usr/bin');
+
+  // npm global (varies by install method)
+  _push(dirs, path.join(HOME, '.npm-global', 'bin'));
+  _push(dirs, path.join(HOME, '.openagents', 'npm-global', 'bin'));
+
+  // nvm
+  const nvmDir = process.env.NVM_DIR || path.join(HOME, '.nvm');
+  try {
+    // Find current nvm version
+    const defaultPath = path.join(nvmDir, 'alias', 'default');
+    if (fs.existsSync(defaultPath)) {
+      const version = fs.readFileSync(defaultPath, 'utf-8').trim();
+      // Resolve alias like 'lts/*' or version number
+      const resolved = _resolveNvmVersion(nvmDir, version);
+      if (resolved) _push(dirs, path.join(nvmDir, 'versions', 'node', resolved, 'bin'));
+    }
+    // Also try current symlink
+    _push(dirs, path.join(nvmDir, 'current', 'bin'));
+  } catch {}
+
+  // fnm
+  const fnmDir = process.env.FNM_DIR || path.join(HOME, '.fnm');
+  try {
+    const defaultDir = path.join(fnmDir, 'aliases', 'default');
+    if (fs.existsSync(defaultDir)) {
+      const target = fs.realpathSync(defaultDir);
+      _push(dirs, path.join(target, 'bin'));
+    }
+  } catch {}
+
+  // volta
+  const voltaHome = process.env.VOLTA_HOME || path.join(HOME, '.volta');
+  _push(dirs, path.join(voltaHome, 'bin'));
+
+  // pip/pipx user installs
+  _push(dirs, path.join(HOME, '.local', 'bin'));
+
+  // cargo
+  _push(dirs, path.join(HOME, '.cargo', 'bin'));
+}
+
+// ---- macOS-specific ----
+
+function _addMacPaths(dirs) {
+  // Homebrew (Apple Silicon + Intel)
+  _push(dirs, '/opt/homebrew/bin');
+  _push(dirs, '/opt/homebrew/sbin');
+  _push(dirs, '/usr/local/bin');
+  _push(dirs, '/usr/local/sbin');
+
+  // MacPorts
+  _push(dirs, '/opt/local/bin');
+
+  // pkgx
+  _push(dirs, path.join(HOME, '.pkgx', 'bin'));
+}
+
+// ---- Helpers ----
+
+function _push(arr, dir) {
+  if (dir) arr.push(dir);
+}
+
+function _resolveNvmVersion(nvmDir, alias) {
+  // Handle direct version like 'v22.14.0'
+  if (alias.startsWith('v')) {
+    return alias;
+  }
+  // Handle aliases like 'lts/*', 'lts/jod', 'default', numeric '22'
+  try {
+    // Try reading alias file
+    const aliasFile = path.join(nvmDir, 'alias', alias.replace('/', path.sep));
+    if (fs.existsSync(aliasFile)) {
+      const target = fs.readFileSync(aliasFile, 'utf-8').trim();
+      return _resolveNvmVersion(nvmDir, target);
+    }
+  } catch {}
+
+  // Try finding latest matching version in versions dir
+  try {
+    const versionsDir = path.join(nvmDir, 'versions', 'node');
+    if (fs.existsSync(versionsDir)) {
+      const versions = fs.readdirSync(versionsDir)
+        .filter(v => v.startsWith('v'))
+        .sort()
+        .reverse();
+      const match = versions.find(v => v.startsWith('v' + alias));
+      if (match) return match;
+      // Just return the latest
+      if (versions.length > 0) return versions[0];
+    }
+  } catch {}
+
+  return null;
+}
+
+module.exports = {
+  getExtraBinDirs,
+  getEnhancedPATH,
+  getEnhancedEnv,
+  whichBinary,
+  IS_WINDOWS,
+  IS_MACOS,
+  SEP,
+};

package/src/registry.js

@@ -0,0 +1,197 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_REGISTRY_URL = 'https://endpoint.openagents.org/v1/agent-registry';
+const CACHE_FILE = 'agent_catalog.json';
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+/**
+ * Agent registry — fetches the catalog of available agent types.
+ *
+ * Priority: remote API → local cache (24h) → bundled registry.json
+ */
+class Registry {
+  constructor(configDir, registryUrl) {
+    this.configDir = configDir;
+    this.registryUrl = registryUrl || DEFAULT_REGISTRY_URL;
+    this.cacheFile = path.join(configDir, CACHE_FILE);
+    this._catalog = null; // in-memory cache
+  }
+
+  /**
+   * Get the full agent catalog. Tries remote, then cache, then bundled.
+   * @returns {Promise<object[]>}
+   */
+  async getCatalog() {
+    if (this._catalog) return this._catalog;
+
+    // Try cache first (avoids network on every call)
+    const cached = this._loadCache();
+    if (cached) {
+      this._catalog = cached;
+      // Refresh in background if stale (but still return cached)
+      this._refreshInBackground();
+      return cached;
+    }
+
+    // No cache — try remote
+    const remote = await this._fetchRemote();
+    if (remote) {
+      this._catalog = remote;
+      return remote;
+    }
+
+    // Fallback to bundled
+    this._catalog = this._loadBundled();
+    return this._catalog;
+  }
+
+  /**
+   * Get catalog synchronously (cache or bundled only, no network).
+   */
+  getCatalogSync() {
+    if (this._catalog) return this._catalog;
+    const cached = this._loadCache();
+    if (cached) { this._catalog = cached; return cached; }
+    this._catalog = this._loadBundled();
+    return this._catalog;
+  }
+
+  /**
+   * Get env field definitions for an agent type.
+   */
+  getEnvFields(agentType) {
+    const catalog = this.getCatalogSync();
+    const entry = catalog.find((e) => e.name === agentType);
+    return entry ? (entry.env_config || []) : [];
+  }
+
+  /**
+   * Get resolve_env rules for an agent type.
+   */
+  getResolveRules(agentType) {
+    const catalog = this.getCatalogSync();
+    const entry = catalog.find((e) => e.name === agentType);
+    if (!entry || !entry.resolve_env) return [];
+    return entry.resolve_env.rules || [];
+  }
+
+  /**
+   * Get a single catalog entry by name.
+   */
+  getEntry(agentType) {
+    const catalog = this.getCatalogSync();
+    const entry = catalog.find((e) => e.name === agentType) || null;
+    // If the cached entry is missing install info, merge with bundled
+    if (entry && !entry.install) {
+      const bundled = this._loadBundled();
+      const bundledEntry = bundled.find((e) => e.name === agentType);
+      if (bundledEntry && bundledEntry.install) {
+        return { ...entry, install: bundledEntry.install };
+      }
+    }
+    return entry;
+  }
+
+  /**
+   * Force refresh from remote API.
+   */
+  async refresh() {
+    const remote = await this._fetchRemote();
+    if (remote) this._catalog = remote;
+    return this._catalog || this.getCatalogSync();
+  }
+
+  // -- Internal --
+
+  _loadCache() {
+    try {
+      if (!fs.existsSync(this.cacheFile)) return null;
+      const stat = fs.statSync(this.cacheFile);
+      if (Date.now() - stat.mtimeMs > CACHE_TTL_MS) return null;
+      const data = JSON.parse(fs.readFileSync(this.cacheFile, 'utf-8'));
+      return Array.isArray(data) ? data : null;
+    } catch {
+      return null;
+    }
+  }
+
+  _saveCache(data) {
+    try {
+      fs.mkdirSync(this.configDir, { recursive: true });
+      fs.writeFileSync(this.cacheFile, JSON.stringify(data, null, 2), 'utf-8');
+    } catch {}
+  }
+
+  _loadBundled() {
+    try {
+      const bundledPath = path.join(__dirname, '..', 'registry.json');
+      if (fs.existsSync(bundledPath)) {
+        return JSON.parse(fs.readFileSync(bundledPath, 'utf-8'));
+      }
+    } catch {}
+    return [];
+  }
+
+  async _fetchRemote() {
+    try {
+      const data = await httpGetJson(this.registryUrl, 5000);
+      // API returns { data: [...] } or directly [...]
+      const catalog = Array.isArray(data) ? data : (data.data || []);
+      if (catalog.length > 0) {
+        this._saveCache(catalog);
+      }
+      return catalog;
+    } catch {
+      return null;
+    }
+  }
+
+  _refreshInBackground() {
+    // Check if cache is older than TTL
+    try {
+      const stat = fs.statSync(this.cacheFile);
+      if (Date.now() - stat.mtimeMs < CACHE_TTL_MS) return;
+    } catch {
+      return;
+    }
+    // Fire and forget
+    this._fetchRemote().catch(() => {});
+  }
+}
+
+/**
+ * Simple HTTP GET that returns parsed JSON. No external dependencies.
+ */
+function httpGetJson(url, timeoutMs = 5000) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const transport = parsedUrl.protocol === 'https:' ? require('https') : require('http');
+
+    const req = transport.get(url, { timeout: timeoutMs }, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        // Follow redirect
+        httpGetJson(res.headers.location, timeoutMs).then(resolve, reject);
+        return;
+      }
+      if (res.statusCode >= 400) {
+        reject(new Error(`HTTP ${res.statusCode}`));
+        res.resume();
+        return;
+      }
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); }
+        catch (e) { reject(e); }
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+  });
+}
+
+module.exports = { Registry };