@openagents-org/agent-launcher 0.2.143 → 0.2.146

package/src/adapters/health-status.js

@@ -0,0 +1,166 @@
+'use strict';
+
+/**
+ * Single source of truth for agent readiness / runtime-failure classification.
+ *
+ * The Install page, the Agents list, the daemon and the TUI must all speak the
+ * same vocabulary about WHY an agent is or isn't usable. Mixing "not installed"
+ * (a genuinely missing executable) with "installed but signed out" or "spawn
+ * failed" is exactly the bug this module exists to prevent.
+ *
+ * Hard rule: REASON.NOT_INSTALLED is ONLY for a binary that cannot be resolved
+ * at all. An installed-but-signed-out agent is REASON.LOGIN_REQUIRED. A binary
+ * that resolved at install time but fails to start at run time is
+ * REASON.RUNTIME_MISSING / REASON.SPAWN_FAILED — never NOT_INSTALLED.
+ *
+ * Everything here is pure and dependency-free so it can be required from the
+ * daemon, the adapters AND the Electron launcher (via
+ * `@openagents-org/agent-launcher/src/adapters/health-status`).
+ */
+
+const REASON = {
+  READY: 'ready',
+  NOT_INSTALLED: 'not_installed', // executable cannot be resolved anywhere
+  LOGIN_REQUIRED: 'login_required', // installed, but no usable login / API key
+  VERSION_INCOMPATIBLE: 'version_incompatible',
+  RUNTIME_MISSING: 'runtime_missing', // resolved at install time, gone at run time
+  SPAWN_FAILED: 'spawn_failed', // child_process spawn errored (ENOENT/EACCES/…)
+  WORKSPACE_JOIN_FAILED: 'workspace_join_failed',
+  HEARTBEAT_FAILED: 'heartbeat_failed',
+  SESSION_REVOKED: 'session_revoked',
+  ADAPTER_CRASHED: 'adapter_crashed',
+};
+
+// Reasons that represent a genuine failure the UI should surface as an error
+// (red dot / X) rather than a benign "needs configuration" state.
+const ERROR_REASONS = new Set([
+  REASON.RUNTIME_MISSING,
+  REASON.SPAWN_FAILED,
+  REASON.WORKSPACE_JOIN_FAILED,
+  REASON.HEARTBEAT_FAILED,
+  REASON.SESSION_REVOKED,
+  REASON.ADAPTER_CRASHED,
+]);
+
+/** True when a reason should render as a hard error (daemon state 'error'). */
+function isErrorReason(reason) {
+  return ERROR_REASONS.has(reason);
+}
+
+/**
+ * Readiness reason from an (installed, ready) pair. The ONLY place that decides
+ * "not_installed vs login_required", so the Install page and the Agents list
+ * can never disagree.
+ */
+function readinessReason(installed, ready) {
+  if (!installed) return REASON.NOT_INSTALLED;
+  return ready ? REASON.READY : REASON.LOGIN_REQUIRED;
+}
+
+/**
+ * Whether a resolved binary path must be launched through a shell. On Windows,
+ * `.cmd`/`.bat` shims (npm/pnpm/yarn global bins, and amp.cmd) are NOT directly
+ * executable via CreateProcess — Node's spawn needs shell:true or it throws
+ * EINVAL/ENOENT. Mirrors the amp adapter's own _spawnAmp handling so the
+ * launcher probe, the Test-connection path and the daemon all behave the same.
+ */
+function shouldUseShellForBinary(bin, platform) {
+  const plat = platform || process.platform;
+  return plat === 'win32' && /\.(cmd|bat)$/i.test(String(bin || ''));
+}
+
+/**
+ * Strip secrets from a diagnostic string before it reaches a log, the daemon
+ * status file or the UI. Removes tokens / api keys / bearer headers / cookies /
+ * URL credentials / long opaque tokens, and caps the length. Never throws.
+ */
+function redactDiagnostic(input, maxLen = 300) {
+  let s = String(input == null ? '' : input);
+  try {
+    s = s
+      // key=value / key: value for sensitive keys (token, api_key, secret, …)
+      .replace(
+        /((?:access[_-]?|api[_-]?|auth[_-]?)?(?:tokens?|keys?|secrets?|passwords?|cookies?)\s*[=:]\s*)(\S+)/gi,
+        '$1<redacted>',
+      )
+      // Authorization: Bearer xxxxx
+      .replace(/(bearer\s+)[A-Za-z0-9._\-]+/gi, '$1<redacted>')
+      // URL userinfo  scheme://user:pass@host
+      .replace(/(\b[a-z][a-z0-9+.\-]*:\/\/)[^/@\s:]+:[^/@\s]+@/gi, '$1<redacted>@')
+      // Known opaque token prefixes
+      .replace(/\b(?:sgp_|sk-|ghp_|gho_|xox[baprs]-)[A-Za-z0-9._\-]+/g, '<redacted>')
+      // Generic long opaque blobs (>= 40 chars)
+      .replace(/\b[A-Za-z0-9_\-]{40,}\b/g, '<redacted>');
+  } catch {
+    /* keep best-effort */
+  }
+  s = s.replace(/\s+/g, ' ').trim();
+  if (s.length > maxLen) s = s.slice(0, maxLen) + '…';
+  return s;
+}
+
+/** Pull a numeric HTTP status off a workspace-client error, if present. */
+function httpStatusOf(err) {
+  if (!err) return null;
+  const sc = err.statusCode != null ? err.statusCode : err.status;
+  return typeof sc === 'number' ? sc : null;
+}
+
+/** Classify a workspace JOIN failure → { reason, message } (redacted). */
+function classifyJoinError(err) {
+  const sc = httpStatusOf(err);
+  let detail;
+  if (sc === 401 || sc === 403) detail = `authentication rejected (HTTP ${sc})`;
+  else if (sc === 404) detail = 'workspace not found (HTTP 404)';
+  else if (typeof sc === 'number') detail = `HTTP ${sc}`;
+  else detail = redactDiagnostic(err && err.message) || 'network error';
+  return {
+    reason: REASON.WORKSPACE_JOIN_FAILED,
+    message: `Workspace join failed: ${detail}`,
+  };
+}
+
+/** Classify a workspace HEARTBEAT failure → { reason, message } (redacted). */
+function classifyHeartbeatError(err) {
+  const sc = httpStatusOf(err);
+  const detail =
+    typeof sc === 'number'
+      ? `HTTP ${sc}`
+      : redactDiagnostic(err && err.message) || 'network error';
+  return {
+    reason: REASON.HEARTBEAT_FAILED,
+    message: `Workspace heartbeat failed: ${detail}`,
+  };
+}
+
+/**
+ * Classify a child_process spawn failure (the CLI could not be started) →
+ * { reason, message } (redacted). `label` names the agent ("Amp"), `bin` is the
+ * resolved path included for diagnostics (it is a filesystem path, not a secret).
+ */
+function classifySpawnError(err, opts) {
+  const { label = 'Agent', bin = null } = opts || {};
+  const code = (err && (err.code || err.errno)) || '';
+  const where = bin ? ` [${bin}]` : '';
+  let detail;
+  if (code === 'ENOENT') detail = `executable not found${where}`;
+  else if (code === 'EACCES' || code === 'EPERM')
+    detail = `permission denied${where}`;
+  else detail = (redactDiagnostic((err && err.message) || code) || 'spawn error') + where;
+  return {
+    reason: REASON.SPAWN_FAILED,
+    message: `${label} process failed to start: ${detail}`,
+  };
+}
+
+module.exports = {
+  REASON,
+  isErrorReason,
+  readinessReason,
+  shouldUseShellForBinary,
+  redactDiagnostic,
+  httpStatusOf,
+  classifyJoinError,
+  classifyHeartbeatError,
+  classifySpawnError,
+};

package/src/adapters/hermes.js

@@ -21,7 +21,7 @@ const { execSync, spawn } = require('child_process');
 
 const BaseAdapter = require('./base');
 const { buildOpenclawSystemPrompt } = require('./workspace-prompt');
-const { whichBinary, getEnhancedEnv } = require('../paths');
+const { whichBinary, whereBinary } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
 const HERMES_INSTALL_HINT = IS_WINDOWS
@@ -76,22 +76,13 @@ class HermesAdapter extends BaseAdapter {
     // Tier 1: PATH (enriched env so we see the dirs the launcher adds; a fresh
     // install updates the user PATH, which the running daemon won't pick up).
     // windowsHide stops a console window from flashing.
-    try {
-      const env = getEnhancedEnv();
-      if (IS_WINDOWS) {
-        // Native Windows is supported (install.ps1). The installer adds
-        // venv\Scripts to the user PATH; a running daemon won't see that update,
-        // hence the enriched env + the explicit candidates in Tier 2.
-        const r = execSync('where hermes.exe 2>nul || where hermes.cmd 2>nul || where hermes 2>nul', {
-          encoding: 'utf-8', timeout: 5000, windowsHide: true, env,
-        });
-        const found = r.split(/\r?\n/)[0].trim();
-        if (found) return found;
-      } else {
-        const found = execSync('which hermes', { encoding: 'utf-8', timeout: 5000, windowsHide: true, env }).trim();
-        if (found) return found;
-      }
-    } catch {}
+    // Codepage-safe lookup (whereBinary forces UTF-8 output + verifies existence
+    // so a non-ASCII/Chinese username isn't mangled into an ENOENT). Native
+    // Windows is supported (install.ps1); the installer adds venv\Scripts to the
+    // user PATH, which a running daemon won't see — hence the enriched env
+    // (whereBinary's default) + the explicit candidates in Tier 2.
+    const viaWhere = whereBinary('hermes');
+    if (viaWhere) return viaWhere;
 
     // Tier 2: Common install locations. The native Windows installer
     // (install.ps1) provisions a portable venv and drops hermes.exe under

package/src/adapters/index.js

@@ -14,6 +14,11 @@ const CursorAdapter = require('./cursor');
 const HermesAdapter = require('./hermes');
 const GeminiAdapter = require('./gemini');
 const KimiAdapter = require('./kimi');
+const AiderAdapter = require('./aider');
+const GooseAdapter = require('./goose');
+const CopilotAdapter = require('./copilot');
+const ClineAdapter = require('./cline');
+const AmpAdapter = require('./amp');
 
 const ADAPTER_MAP = {
   openclaw: OpenClawAdapter,
@@ -25,11 +30,16 @@ const ADAPTER_MAP = {
   hermes: HermesAdapter,
   gemini: GeminiAdapter,
   kimi: KimiAdapter,
+  aider: AiderAdapter,
+  goose: GooseAdapter,
+  copilot: CopilotAdapter,
+  cline: ClineAdapter,
+  amp: AmpAdapter,
 };
 
 /**
  * Create an adapter instance for the given agent type.
- * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes, gemini, kimi)
+ * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes, gemini, kimi, aider, goose, copilot, cline, amp)
  * @param {object} opts - Adapter constructor options
  * @returns {BaseAdapter}
  */
@@ -52,6 +62,11 @@ module.exports = {
   HermesAdapter,
   GeminiAdapter,
   KimiAdapter,
+  AiderAdapter,
+  GooseAdapter,
+  CopilotAdapter,
+  ClineAdapter,
+  AmpAdapter,
   createAdapter,
   ADAPTER_MAP,
 };

package/src/adapters/nanoclaw-bridge.js

@@ -0,0 +1,264 @@
+/**
+ * NanoclawBridge — client side of the local IPC to the native NanoClaw
+ * `openagents` channel.
+ *
+ * The channel (running inside the NanoClaw host) owns a Unix-socket SERVER at
+ * `<home>/data/openagents.sock`; this bridge is the CLIENT. We send `inbound`
+ * frames (a workspace message addressed to an OpenAgents channel) and receive
+ * `outbound` / `status` / `error` frames (the agent container's replies and
+ * liveness, correlated by `platformId`). The channel does the native
+ * router→session→container routing; we never touch NanoClaw's database.
+ *
+ * Connection is resilient: a dropped socket triggers exponential-backoff
+ * reconnect (the NanoClaw host may restart, or the channel may load late).
+ * The workspace token is never sent over this socket.
+ */
+
+'use strict';
+
+const net = require('net');
+const { EventEmitter } = require('events');
+
+const proto = require('./nanoclaw-protocol');
+const { isPathSafe } = require('./nanoclaw-control');
+
+const noop = () => {};
+
+// Upper bound on the inbound line buffer. The bridge speaks newline-delimited
+// JSON control frames (small); a peer that streams data without a newline would
+// otherwise grow the buffer unbounded. The trust boundary is the same OS user,
+// so this guards against a malfunctioning/compromised local peer, not a remote
+// attacker. 8 MiB is far above any legitimate frame.
+const MAX_BUFFER_BYTES = 8 * 1024 * 1024;
+
+class NanoclawBridge extends EventEmitter {
+  /**
+   * @param {string} socketPath
+   * @param {object} opts
+   * @param {string} opts.workspace
+   * @param {string} opts.agent
+   * @param {()=>(string|null)} [opts.secretProvider]  read the current handshake secret (fresh per connect)
+   * @param {(m:string)=>void} [opts.log]
+   * @param {number} [opts.minBackoffMs]
+   * @param {number} [opts.maxBackoffMs]
+   */
+  constructor(socketPath, opts = {}) {
+    super();
+    this.socketPath = socketPath;
+    this.workspace = opts.workspace || '';
+    this.agent = opts.agent || '';
+    this._secretProvider = typeof opts.secretProvider === 'function' ? opts.secretProvider : () => null;
+    this._log = opts.log || noop;
+    this._minBackoff = opts.minBackoffMs || 500;
+    this._maxBackoff = opts.maxBackoffMs || 8000;
+
+    this._sock = null;
+    this._buffer = '';
+    this._connected = false;
+    this._ready = false;
+    this._closed = false;
+    this._attempt = 0;
+    this._reconnectTimer = null;
+  }
+
+  isConnected() {
+    return this._connected && !this._closed;
+  }
+  isReady() {
+    return this._ready && !this._closed;
+  }
+
+  /** Begin connecting (idempotent). Resolves on first successful TCP connect. */
+  connect() {
+    this._closed = false;
+    if (this._sock) return;
+    this._openOnce();
+  }
+
+  _openOnce() {
+    if (this._closed) return;
+    this._buffer = '';
+
+    // Refuse a symlinked socket path (path-escape / redirection guard).
+    const safe = isPathSafe(this.socketPath);
+    if (!safe.ok) {
+      this._log(`bridge refusing unsafe socket path: ${safe.reason}`);
+      this.emit('socket-error', Object.assign(new Error(safe.reason), { code: 'UNSAFE_PATH' }));
+      this._scheduleReconnect();
+      return;
+    }
+
+    // Read the handshake secret fresh every connect (handles host restart /
+    // secret rotation, and re-auth on reconnect).
+    const secret = this._secretProvider();
+    if (!secret) {
+      this._log('bridge: handshake secret not available yet — will retry');
+      this.emit('auth-pending');
+      this._scheduleReconnect();
+      return;
+    }
+
+    const sock = net.createConnection(this.socketPath);
+    this._sock = sock;
+
+    sock.on('connect', () => {
+      this._connected = true;
+      this._attempt = 0;
+      this._log(`bridge connected: ${this.socketPath}`);
+      // Handshake — identify ourselves + present the local secret. The channel
+      // replies 'ready' only on a valid secret + matching protocol.
+      try {
+        sock.write(proto.buildHello(this.workspace, this.agent, secret));
+      } catch (e) {
+        this._log(`bridge hello write failed: ${e.message}`);
+      }
+      this.emit('connect');
+    });
+
+    sock.on('data', (chunk) => {
+      this._buffer += chunk.toString('utf8');
+      const { frames, rest } = proto.parseFrames(this._buffer);
+      this._buffer = rest;
+      // Guard against an unbounded line with no frame delimiter — drop the
+      // buffer and reset the connection rather than growing memory without limit.
+      if (this._buffer.length > MAX_BUFFER_BYTES) {
+        this._log(`bridge buffer exceeded ${MAX_BUFFER_BYTES} bytes without a complete frame — resetting connection`);
+        this._buffer = '';
+        try { sock.destroy(); } catch { /* best-effort */ }
+        return;
+      }
+      for (const frame of frames) this._onFrame(frame);
+    });
+
+    // Always attach an error listener: a SIGKILL'd/closed peer can emit
+    // 'error' (EPIPE/ECONNRESET) which, unhandled, crashes the process.
+    sock.on('error', (err) => {
+      this._log(`bridge socket error: ${err.code || err.message}`);
+      this.emit('socket-error', err);
+    });
+
+    sock.on('close', () => {
+      const wasReady = this._ready;
+      this._connected = false;
+      this._ready = false;
+      this._sock = null;
+      if (wasReady || this._attempt === 0) this.emit('disconnect');
+      this._scheduleReconnect();
+    });
+  }
+
+  _onFrame(frame) {
+    switch (frame.op) {
+      case 'ready':
+        this._ready = true;
+        this._log(`bridge ready (channel=${frame.channelType || 'openagents'}, proto=${frame.protocol})`);
+        this.emit('ready', frame);
+        break;
+      case 'outbound':
+        this.emit('outbound', frame);
+        break;
+      case 'status':
+        this.emit('status', frame);
+        break;
+      case 'error':
+        if (frame.code === 'auth_failed' || frame.code === 'incompatible_version' || frame.code === 'single_connection') {
+          this._log(`bridge handshake rejected: ${frame.code}`);
+          this.emit('auth-failed', frame.code);
+        }
+        this.emit('error-frame', frame);
+        break;
+      case 'dropped':
+        // A queued outbound the channel could not retain (overflow / expiry).
+        this.emit('dropped', frame);
+        break;
+      case 'pong':
+        this.emit('pong', frame);
+        break;
+      default:
+        // Forward-compat: ignore unknown ops.
+        break;
+    }
+  }
+
+  _scheduleReconnect() {
+    if (this._closed) return;
+    if (this._reconnectTimer) return;
+    this._attempt += 1;
+    const delay = Math.min(this._maxBackoff, this._minBackoff * 2 ** Math.min(this._attempt - 1, 6));
+    this.emit('reconnecting', this._attempt, delay);
+    this._reconnectTimer = setTimeout(() => {
+      this._reconnectTimer = null;
+      this._openOnce();
+    }, delay);
+    if (this._reconnectTimer.unref) this._reconnectTimer.unref();
+  }
+
+  /**
+   * Write an already-encoded frame string. Returns true if written.
+   * Throws if not connected (caller decides whether to surface or wait).
+   */
+  _write(frameStr) {
+    if (!this._sock || !this._connected) {
+      const e = new Error('NanoClaw bridge not connected');
+      e.code = 'NOT_CONNECTED';
+      throw e;
+    }
+    return this._sock.write(frameStr);
+  }
+
+  /** Inject a workspace message into NanoClaw. `fields` per proto.buildInbound. */
+  sendInbound(fields) {
+    return this._write(proto.buildInbound(fields));
+  }
+
+  sendCancel(platformId, msgId) {
+    try {
+      return this._write(proto.buildCancel(platformId, msgId));
+    } catch {
+      return false; // cancel is best-effort
+    }
+  }
+
+  /** Acknowledge a delivered outbound so the channel stops holding/replaying it. */
+  sendAck(outId, platformId) {
+    if (!outId) return false;
+    try {
+      return this._write(proto.buildAck(outId, platformId));
+    } catch {
+      return false; // will be re-driven by the channel's replay on reconnect
+    }
+  }
+
+  ping() {
+    try {
+      return this._write(proto.buildPing());
+    } catch {
+      return false;
+    }
+  }
+
+  /** Stop reconnecting and tear down the socket. */
+  close() {
+    this._closed = true;
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
+    const sock = this._sock;
+    this._sock = null;
+    this._connected = false;
+    this._ready = false;
+    if (sock) {
+      try {
+        sock.removeAllListeners('close');
+        sock.on('error', noop); // swallow teardown EPIPE
+        sock.end();
+        sock.destroy();
+      } catch {
+        /* best-effort */
+      }
+    }
+  }
+}
+
+module.exports = { NanoclawBridge };