@openagents-org/agent-connector 0.1.0

package/src/daemon.js

@@ -0,0 +1,541 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn, execSync } = require('child_process');
+const os = require('os');
+
+const IS_WINDOWS = process.platform === 'win32';
+
+/**
+ * Agent process lifecycle manager.
+ *
+ * Spawns agent subprocesses, monitors them with auto-restart + backoff,
+ * writes status to disk, processes commands from daemon.cmd, and handles
+ * graceful shutdown.
+ *
+ * Compatible with the Python SDK's daemon — reads the same config files,
+ * writes the same status format, and supports the same command protocol.
+ */
+class Daemon {
+  constructor(config, envManager, registry) {
+    this.config = config;
+    this.envManager = envManager;
+    this.registry = registry;
+
+    // State
+    this._processes = {};     // agentName → { proc, state, restarts, startedAt, lastError }
+    this._stoppedAgents = new Set();
+    this._shuttingDown = false;
+    this._statusInterval = null;
+    this._cmdInterval = null;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Public API
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Start all configured agents and block until shutdown.
+   * Call this from the foreground daemon process.
+   */
+  async start() {
+    const agents = this.config.getAgents();
+    for (const agent of agents) {
+      this._launchAgent(agent);
+    }
+
+    // Install signal handlers
+    const shutdown = () => this.stop();
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+    if (!IS_WINDOWS && process.on) {
+      try { process.on('SIGHUP', () => this._reload()); } catch {}
+    }
+
+    // Write PID file
+    this._writePid();
+
+    // Periodic status + command check
+    this._statusInterval = setInterval(() => {
+      this._writeStatus();
+      this._processCommands();
+    }, 5000);
+
+    this._writeStatus();
+    this._log(`Daemon started with ${agents.length} agent(s)`);
+
+    // Block until shutdown
+    await new Promise((resolve) => {
+      this._shutdownResolve = resolve;
+    });
+  }
+
+  /**
+   * Gracefully stop all agents and exit.
+   */
+  async stop() {
+    if (this._shuttingDown) return;
+    this._shuttingDown = true;
+    this._log('Shutting down...');
+
+    if (this._statusInterval) clearInterval(this._statusInterval);
+    if (this._cmdInterval) clearInterval(this._cmdInterval);
+
+    // Kill all child processes
+    const kills = Object.keys(this._processes).map((name) =>
+      this._killAgent(name, 5000)
+    );
+    await Promise.all(kills);
+
+    this._writeStatus();
+    this._cleanupPid();
+    this._log('Daemon stopped');
+
+    if (this._shutdownResolve) this._shutdownResolve();
+  }
+
+  /**
+   * Stop a single agent by name.
+   */
+  async stopAgent(agentName) {
+    this._stoppedAgents.add(agentName);
+    await this._killAgent(agentName, 5000);
+    this._writeStatus();
+  }
+
+  /**
+   * Restart a single agent by name.
+   */
+  async restartAgent(agentName) {
+    await this.stopAgent(agentName);
+    this._stoppedAgents.delete(agentName);
+
+    const agent = this.config.getAgent(agentName);
+    if (agent) {
+      this._launchAgent(agent);
+      this._writeStatus();
+    }
+  }
+
+  /**
+   * Get current status of all agents.
+   */
+  getStatus() {
+    const result = {};
+    for (const [name, info] of Object.entries(this._processes)) {
+      result[name] = {
+        state: info.state,
+        type: info.type || 'unknown',
+        network: info.network || '(local)',
+        restarts: info.restarts,
+        started_at: info.startedAt || null,
+        last_error: info.lastError || null,
+      };
+    }
+    return result;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Daemonize — launch as background process
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Launch the daemon as a background process.
+   * The parent process prints info and exits; the child runs `start()`.
+   * @param {string[]} foregroundArgs - CLI args for the foreground child process
+   */
+  static daemonize(configDir, foregroundArgs) {
+    const logFile = path.join(configDir, 'daemon.log');
+    const pidFile = path.join(configDir, 'daemon.pid');
+
+    fs.mkdirSync(configDir, { recursive: true });
+    const logFd = fs.openSync(logFile, 'a');
+
+    if (IS_WINDOWS) {
+      // Windows: re-launch as detached with CREATE_NO_WINDOW
+      const proc = spawn(process.execPath, foregroundArgs, {
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+        windowsHide: true,
+        env: { ...process.env },
+      });
+      proc.unref();
+      fs.writeFileSync(pidFile, String(proc.pid), 'utf-8');
+      fs.closeSync(logFd);
+      console.log(`Daemon started (PID ${proc.pid})`);
+      console.log(`Logs: ${logFile}`);
+      console.log('Stop: agent-connector down');
+    } else {
+      // Unix: spawn detached child
+      const proc = spawn(process.execPath, foregroundArgs, {
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+        env: { ...process.env },
+      });
+      proc.unref();
+      fs.writeFileSync(pidFile, String(proc.pid), 'utf-8');
+      fs.closeSync(logFd);
+      console.log(`Daemon started (PID ${proc.pid})`);
+      console.log(`Logs: ${logFile}`);
+      console.log('Stop: agent-connector down');
+    }
+  }
+
+  /**
+   * Stop a running daemon by reading PID file and sending signal.
+   * @returns {boolean} true if stopped
+   */
+  static stopDaemon(configDir) {
+    const pidFile = path.join(configDir, 'daemon.pid');
+    const statusFile = path.join(configDir, 'daemon.status.json');
+
+    const pid = Daemon._readPid(pidFile);
+    if (!pid) return false;
+
+    try {
+      if (IS_WINDOWS) {
+        execSync(`taskkill /PID ${pid}`, { stdio: 'ignore', timeout: 5000 });
+      } else {
+        process.kill(pid, 'SIGTERM');
+      }
+    } catch {}
+
+    // Wait for process to die
+    for (let i = 0; i < 20; i++) {
+      if (!Daemon._isAlive(pid)) {
+        try { fs.unlinkSync(pidFile); } catch {}
+        try { fs.unlinkSync(statusFile); } catch {}
+        return true;
+      }
+      // Busy-wait 500ms (sync, used only in CLI stop command)
+      execSync(IS_WINDOWS ? 'timeout /t 1 /nobreak >nul' : 'sleep 0.5', {
+        stdio: 'ignore', timeout: 2000,
+      });
+    }
+
+    // Force kill
+    try {
+      if (IS_WINDOWS) {
+        execSync(`taskkill /F /PID ${pid}`, { stdio: 'ignore', timeout: 5000 });
+      } else {
+        process.kill(pid, 'SIGKILL');
+      }
+    } catch {}
+
+    try { fs.unlinkSync(pidFile); } catch {}
+    try { fs.unlinkSync(statusFile); } catch {}
+    return true;
+  }
+
+  /**
+   * Read daemon PID, returning null if not running.
+   */
+  static readDaemonPid(configDir) {
+    return Daemon._readPid(path.join(configDir, 'daemon.pid'));
+  }
+
+  // ---------------------------------------------------------------------------
+  // Internal — agent launch
+  // ---------------------------------------------------------------------------
+
+  _launchAgent(agentCfg) {
+    const name = agentCfg.name;
+    const type = agentCfg.type || 'openclaw';
+
+    this._stoppedAgents.delete(name);
+
+    const info = {
+      type,
+      network: agentCfg.network || '(local)',
+      state: 'starting',
+      restarts: 0,
+      startedAt: null,
+      lastError: null,
+      proc: null,
+      _backoff: 2,
+    };
+    this._processes[name] = info;
+
+    this._spawnLoop(name, agentCfg, info);
+  }
+
+  async _spawnLoop(name, agentCfg, info) {
+    const cmd = this._getLaunchCommand(agentCfg);
+    if (!cmd) {
+      info.state = 'running';
+      info.startedAt = new Date().toISOString();
+      this._log(`${name} registered (no launch command for ${agentCfg.type})`);
+      return;
+    }
+
+    const env = this._buildAgentEnv(agentCfg);
+    const cwd = agentCfg.path || undefined;
+
+    while (!this._shuttingDown && !this._stoppedAgents.has(name)) {
+      try {
+        info.state = 'starting';
+        this._writeStatus();
+
+        const proc = this._spawnAgent(cmd, { env, cwd });
+        info.proc = proc;
+        info.state = 'running';
+        info.startedAt = new Date().toISOString();
+        this._writeStatus();
+        this._log(`${name} running (PID ${proc.pid})`);
+
+        // Stream output to log
+        if (proc.stdout) {
+          proc.stdout.on('data', (chunk) => {
+            const lines = chunk.toString().split('\n').filter(Boolean);
+            for (const line of lines) {
+              this._log(`[${name}] ${line}`);
+            }
+          });
+        }
+
+        const exitCode = await new Promise((resolve) => {
+          proc.on('exit', (code) => resolve(code));
+          proc.on('error', (err) => {
+            this._log(`${name} spawn error: ${err.message}`);
+            resolve(1);
+          });
+        });
+
+        info.proc = null;
+
+        if (this._stoppedAgents.has(name)) {
+          this._log(`${name} was stopped, not restarting`);
+          break;
+        }
+
+        if (exitCode === 0) {
+          this._log(`${name} exited cleanly`);
+          break;
+        }
+
+        throw new Error(`Process exited with code ${exitCode}`);
+      } catch (err) {
+        if (this._stoppedAgents.has(name) || this._shuttingDown) break;
+
+        info.restarts++;
+        info.state = 'error';
+        info.lastError = (err.message || String(err)).slice(0, 200);
+        this._writeStatus();
+        this._log(`${name} crashed: ${info.lastError}, restarting in ${info._backoff}s (attempt ${info.restarts})`);
+
+        await this._sleep(info._backoff * 1000);
+        info._backoff = Math.min(info._backoff * 2, 60);
+      }
+    }
+
+    info.state = 'stopped';
+    this._writeStatus();
+  }
+
+  _spawnAgent(cmd, opts) {
+    const [binary, ...args] = cmd;
+    const spawnOpts = {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: opts.env,
+      cwd: opts.cwd,
+    };
+
+    if (IS_WINDOWS && binary.toLowerCase().endsWith('.cmd')) {
+      spawnOpts.shell = true;
+    }
+
+    const proc = spawn(binary, args, spawnOpts);
+
+    // Merge stderr into stdout handler
+    if (proc.stderr) {
+      proc.stderr.on('data', (chunk) => {
+        if (proc.stdout) proc.stdout.emit('data', chunk);
+      });
+    }
+
+    return proc;
+  }
+
+  _getLaunchCommand(agentCfg) {
+    const entry = this.registry.getEntry(agentCfg.type);
+    if (!entry || !entry.install || !entry.install.binary) return null;
+
+    const binary = entry.install.binary;
+    const args = [];
+
+    // Add launch args from registry
+    if (entry.launch && entry.launch.args) {
+      for (const arg of entry.launch.args) {
+        args.push(arg.replace(/\{agent_name\}/g, agentCfg.name));
+      }
+    }
+
+    return [binary, ...args];
+  }
+
+  _buildAgentEnv(agentCfg) {
+    const type = agentCfg.type || 'openclaw';
+    const saved = this.envManager.load(type);
+    const resolved = this.envManager.resolve(type, saved, this.registry);
+    const merged = { ...saved, ...resolved, ...(agentCfg.env || {}) };
+    return { ...process.env, ...merged };
+  }
+
+  // ---------------------------------------------------------------------------
+  // Internal — agent kill
+  // ---------------------------------------------------------------------------
+
+  async _killAgent(name, timeoutMs) {
+    const info = this._processes[name];
+    if (!info || !info.proc) {
+      if (info) info.state = 'stopped';
+      return;
+    }
+
+    const proc = info.proc;
+    info.proc = null;
+
+    // Try graceful termination
+    try {
+      if (IS_WINDOWS) {
+        execSync(`taskkill /PID ${proc.pid}`, { stdio: 'ignore', timeout: 5000 });
+      } else {
+        proc.kill('SIGTERM');
+      }
+    } catch {}
+
+    // Wait for exit
+    const died = await Promise.race([
+      new Promise((resolve) => proc.on('exit', () => resolve(true))),
+      this._sleep(timeoutMs).then(() => false),
+    ]);
+
+    if (!died) {
+      try {
+        if (IS_WINDOWS) {
+          execSync(`taskkill /F /PID ${proc.pid}`, { stdio: 'ignore', timeout: 5000 });
+        } else {
+          proc.kill('SIGKILL');
+        }
+      } catch {}
+    }
+
+    info.state = 'stopped';
+  }
+
+  // ---------------------------------------------------------------------------
+  // Internal — status, commands, PID
+  // ---------------------------------------------------------------------------
+
+  _writeStatus() {
+    try {
+      const status = { agents: this.getStatus(), pid: process.pid };
+      fs.writeFileSync(this.config.statusFile, JSON.stringify(status, null, 2), 'utf-8');
+    } catch {}
+  }
+
+  _processCommands() {
+    const cmdFile = this.config.cmdFile;
+    try {
+      if (!fs.existsSync(cmdFile)) return;
+      const raw = fs.readFileSync(cmdFile, 'utf-8').trim();
+      fs.unlinkSync(cmdFile);
+      if (!raw) return;
+
+      for (const line of raw.split('\n')) {
+        const cmd = line.trim();
+        if (cmd.startsWith('stop:')) {
+          const agentName = cmd.slice(5).trim();
+          this.stopAgent(agentName);
+        } else if (cmd.startsWith('restart:')) {
+          const agentName = cmd.slice(8).trim();
+          this.restartAgent(agentName);
+        } else if (cmd === 'reload') {
+          this._reload();
+        }
+      }
+    } catch {}
+  }
+
+  _reload() {
+    this._log('Reloading config...');
+    const oldAgents = new Map(this.config.getAgents().map((a) => [a.name, a]));
+    // Re-read config from disk (Config reads fresh on each call)
+    const newAgents = new Map(this.config.getAgents().map((a) => [a.name, a]));
+
+    // Stop removed agents
+    for (const name of oldAgents.keys()) {
+      if (!newAgents.has(name)) {
+        this.stopAgent(name);
+        this._log(`Reload: stopped removed agent '${name}'`);
+      }
+    }
+
+    // Start new agents
+    for (const [name, agent] of newAgents) {
+      if (!oldAgents.has(name)) {
+        this._launchAgent(agent);
+        this._log(`Reload: started new agent '${name}'`);
+      }
+    }
+
+    this._writeStatus();
+  }
+
+  _writePid() {
+    try {
+      fs.writeFileSync(this.config.pidFile, String(process.pid), 'utf-8');
+    } catch {}
+  }
+
+  _cleanupPid() {
+    try { fs.unlinkSync(this.config.pidFile); } catch {}
+    try { fs.unlinkSync(this.config.statusFile); } catch {}
+  }
+
+  _log(msg) {
+    const ts = new Date().toISOString();
+    const line = `${ts} INFO daemon: ${msg}`;
+    try {
+      fs.appendFileSync(this.config.logFile, line + '\n', 'utf-8');
+    } catch {}
+    if (!this._shuttingDown) {
+      // Also log to console when running in foreground
+      console.log(line);
+    }
+  }
+
+  _sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  // ---------------------------------------------------------------------------
+  // Static helpers
+  // ---------------------------------------------------------------------------
+
+  static _readPid(pidFile) {
+    try {
+      if (!fs.existsSync(pidFile)) return null;
+      const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+      if (isNaN(pid)) return null;
+      if (Daemon._isAlive(pid)) return pid;
+      // Stale
+      try { fs.unlinkSync(pidFile); } catch {}
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  static _isAlive(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+module.exports = { Daemon };

package/src/env.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Manages ~/.openagents/env/<type>.env files and resolve_env rules.
+ *
+ * Env files use key=value format (one per line, # for comments).
+ * resolve_env maps generic LLM_* vars to provider-specific vars
+ * (e.g. LLM_API_KEY → OPENAI_API_KEY or ANTHROPIC_API_KEY).
+ */
+class EnvManager {
+  constructor(configDir) {
+    this.envDir = path.join(configDir, 'env');
+  }
+
+  /**
+   * Load env vars from ~/.openagents/env/<agentType>.env
+   */
+  load(agentType) {
+    const envFile = path.join(this.envDir, `${agentType}.env`);
+    const env = {};
+    try {
+      if (!fs.existsSync(envFile)) return env;
+      const lines = fs.readFileSync(envFile, 'utf-8').split('\n');
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#') || !trimmed.includes('=')) continue;
+        const idx = trimmed.indexOf('=');
+        const key = trimmed.slice(0, idx).trim();
+        const val = trimmed.slice(idx + 1).trim();
+        if (key) env[key] = val;
+      }
+    } catch {}
+    return env;
+  }
+
+  /**
+   * Save env vars to ~/.openagents/env/<agentType>.env
+   * Merges with existing values (new values override).
+   */
+  save(agentType, env) {
+    fs.mkdirSync(this.envDir, { recursive: true });
+    const envFile = path.join(this.envDir, `${agentType}.env`);
+    const existing = this.load(agentType);
+    const merged = { ...existing, ...env };
+    const lines = Object.entries(merged)
+      .filter(([, v]) => v !== null && v !== undefined && v !== '')
+      .map(([k, v]) => `${k}=${v}`);
+    fs.writeFileSync(envFile, lines.join('\n') + '\n', 'utf-8');
+  }
+
+  /**
+   * Delete env file for an agent type.
+   */
+  delete(agentType) {
+    const envFile = path.join(this.envDir, `${agentType}.env`);
+    try { fs.unlinkSync(envFile); } catch {}
+  }
+
+  /**
+   * Apply resolve_env rules to map generic vars to provider-specific vars.
+   *
+   * Rules format (from YAML plugin definition):
+   *   { from: 'LLM_API_KEY', to: 'OPENAI_API_KEY', unless_base_url_contains: 'anthropic' }
+   *   { from: 'LLM_API_KEY', to: 'ANTHROPIC_API_KEY', if_base_url_contains: 'anthropic' }
+   *   { from: 'LLM_BASE_URL', to: 'OPENAI_BASE_URL' }
+   *
+   * @param {object} saved - The saved env vars (from the env file)
+   * @param {object[]} rules - The resolve_env rules from the registry
+   * @returns {object} - The resolved env vars (provider-specific)
+   */
+  resolve(agentType, saved, registry) {
+    const rules = registry ? registry.getResolveRules(agentType) : [];
+    if (!rules || rules.length === 0) return saved;
+
+    const resolved = {};
+    const baseUrl = (saved.LLM_BASE_URL || '').toLowerCase();
+
+    for (const rule of rules) {
+      const src = rule.from || '';
+      const dst = rule.to || '';
+      const srcVal = saved[src];
+      if (!srcVal || !dst) continue;
+
+      // Conditional rules based on base URL
+      if (rule.if_base_url_contains) {
+        if (!baseUrl.includes(rule.if_base_url_contains.toLowerCase())) continue;
+      }
+      if (rule.unless_base_url_contains) {
+        if (baseUrl.includes(rule.unless_base_url_contains.toLowerCase())) continue;
+      }
+
+      resolved[dst] = srcVal;
+    }
+
+    return resolved;
+  }
+
+  /**
+   * Get the full effective env for an agent: saved + resolved.
+   */
+  getEffective(agentType, registry) {
+    const saved = this.load(agentType);
+    const resolved = this.resolve(agentType, saved, registry);
+    return { ...saved, ...resolved };
+  }
+}
+
+module.exports = { EnvManager };