@openagents-org/agent-launcher 0.2.134 → 0.2.135

package/icons/hermes.svg

@@ -0,0 +1 @@
+<svg fill="currentColor" viewBox="0 0 24 24" width="1em" height="1em" xmlns="http://www.w3.org/2000/svg"><title>Hermes</title><circle cx="12" cy="3.5" r="1.75"/><path d="M11 6h2v16h-2z"/><path d="M13 7.5c2.5 0 4.5-1.2 5.8-2.8l1.4 1c-1.6 2-4.2 3.5-7.2 3.5V7.5zM11 7.5c-2.5 0-4.5-1.2-5.8-2.8l-1.4 1C5.4 7.7 8 9.2 11 9.2V7.5z"/><path d="M13 12.5c2.2 0 4-1 5.3-2.5l1.4 1c-1.6 1.8-3.8 3.2-6.7 3.2v-1.7zM11 12.5c-2.2 0-4-1-5.3-2.5l-1.4 1C5.9 13.3 8.1 14.7 11 14.7v-1.7z"/></svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagents-org/agent-launcher",
-  "version": "0.2.134",
+  "version": "0.2.135",
   "description": "OpenAgents Launcher — install, configure, and run AI coding agents from your terminal",
   "main": "src/index.js",
   "bin": {

package/registry.json

@@ -537,23 +537,6 @@
       "not_ready_message": "Not configured \u2014 press e to configure"
     }
   },
-  {
-    "name": "swebench",
-    "label": "SWE-bench Agent",
-    "description": "Language model agent for software engineering tasks",
-    "homepage": "https://swe-agent.com",
-    "tags": [
-      "coding",
-      "benchmarks",
-      "research"
-    ],
-    "install": {
-      "binary": "sweagent",
-      "macos": "pip install sweagent",
-      "linux": "pip install sweagent",
-      "windows": "pip install sweagent"
-    }
-  },
   {
     "name": "kimi",
     "label": "Kimi",

package/src/adapters/claude.js

@@ -38,6 +38,8 @@ class ClaudeAdapter extends BaseAdapter {
     this._stoppingChannels = new Set();
     this._persistentProcs = {}; // channel → { proc, lineBuffer, pendingLines, idleTimer, messageResolve }
     this._IDLE_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
+    this._WATCHDOG_INTERVAL_MS = 15_000; // 15s between checks
+    this._WATCHDOG_MAX_TIMEOUTS = 20;    // 20 * 15s = 5 min of silence → kill
     this._sessionsFile = path.join(
       os.homedir(), '.openagents', 'sessions',
       `${this.workspaceId}_${this.agentName}.json`
@@ -579,6 +581,7 @@ class ClaudeAdapter extends BaseAdapter {
     const pp = this._persistentProcs[channel];
     if (!pp) return;
     if (pp.idleTimer) clearTimeout(pp.idleTimer);
+    this._stopWatchdog(pp);
     this._stopProcess(pp.proc).catch(() => {});
     delete this._persistentProcs[channel];
   }
@@ -597,6 +600,49 @@ class ClaudeAdapter extends BaseAdapter {
     }, this._IDLE_TIMEOUT_MS);
   }
 
+  /**
+   * Start a watchdog that kills the persistent process if stdout goes
+   * silent for too long while a message is in flight.  Pauses during
+   * tool execution (awaitingToolResult) since long-running commands
+   * like builds or sleep produce no stdout legitimately.
+   */
+  _startWatchdog(pp) {
+    this._stopWatchdog(pp);
+    pp.lastStdoutTime = Date.now();
+    let consecutiveTimeouts = 0;
+
+    pp.watchdogTimer = setInterval(async () => {
+      if (!pp.messageResolve) { consecutiveTimeouts = 0; return; }
+      if (pp.awaitingToolResult) { consecutiveTimeouts = 0; return; }
+
+      const elapsed = Date.now() - pp.lastStdoutTime;
+      if (elapsed < this._WATCHDOG_INTERVAL_MS) { consecutiveTimeouts = 0; return; }
+
+      consecutiveTimeouts++;
+      pp.lastStdoutTime = Date.now();
+
+      if (consecutiveTimeouts === 2) {
+        try { await this.sendStatus(pp.msgChannel, 'Still processing...'); } catch {}
+      }
+
+      if (consecutiveTimeouts >= this._WATCHDOG_MAX_TIMEOUTS) {
+        this._log(`Watchdog: process unresponsive for ${consecutiveTimeouts * 15}s on ${pp.msgChannel} — killing`);
+        this._stopWatchdog(pp);
+        try { await this.sendError(pp.msgChannel, 'Agent process became unresponsive and was restarted.'); } catch {}
+        if (pp.messageResolve) {
+          const resolve = pp.messageResolve;
+          pp.messageResolve = null;
+          resolve({ exited: true, error: new Error('watchdog timeout') });
+        }
+        this._killPersistentProc(pp.msgChannel);
+      }
+    }, this._WATCHDOG_INTERVAL_MS);
+  }
+
+  _stopWatchdog(pp) {
+    if (pp.watchdogTimer) { clearInterval(pp.watchdogTimer); pp.watchdogTimer = null; }
+  }
+
   /**
    * Spawn a persistent Claude process for a channel that accepts messages
    * via stdin (--input-format stream-json). Returns the persistent proc entry.
@@ -651,6 +697,9 @@ class ClaudeAdapter extends BaseAdapter {
       everPostedAnything: false,
       stderrBuf: '',
       alive: true,
+      lastStdoutTime: Date.now(),
+      watchdogTimer: null,
+      awaitingToolResult: false,
     };
 
     if (proc.stderr) {
@@ -665,6 +714,7 @@ class ClaudeAdapter extends BaseAdapter {
       const eventType = event.type;
 
       if (eventType === 'assistant') {
+        pp.awaitingToolResult = false;
         const blocks = (event.message || {}).content || [];
         for (const block of blocks) {
           if (block.type === 'text' && block.text && block.text.trim()) {
@@ -680,6 +730,7 @@ class ClaudeAdapter extends BaseAdapter {
             pp.hasToolUseSinceLastText = true;
             pp.postedThinking = false;
             pp.lastResponseText.length = 0;
+            pp.awaitingToolResult = true;
             const toolName = block.name || '';
             if (toolName === 'TodoWrite' && block.input && block.input.todos) {
               try {
@@ -707,6 +758,7 @@ class ClaudeAdapter extends BaseAdapter {
           }
         }
       } else if (eventType === 'result') {
+        pp.awaitingToolResult = false;
         const sessionId = event.session_id;
         if (sessionId) {
           this._channelSessions[pp.msgChannel] = sessionId;
@@ -732,6 +784,7 @@ class ClaudeAdapter extends BaseAdapter {
 
     proc.stdout.on('data', (chunk) => {
       pp.lineBuffer += chunk.toString('utf-8');
+      pp.lastStdoutTime = Date.now();
       const lines = pp.lineBuffer.split('\n');
       pp.lineBuffer = lines.pop();
       for (const line of lines) {
@@ -743,6 +796,7 @@ class ClaudeAdapter extends BaseAdapter {
       this._log(`Persistent process exited: channel=${channel} code=${code}`);
       pp.alive = false;
       if (pp.idleTimer) clearTimeout(pp.idleTimer);
+      this._stopWatchdog(pp);
       if (pp.messageResolve) {
         pp.messageResolve({ exited: true, code });
         pp.messageResolve = null;
@@ -754,6 +808,7 @@ class ClaudeAdapter extends BaseAdapter {
     proc.on('error', (err) => {
       this._log(`Persistent process error: ${err.message}`);
       pp.alive = false;
+      this._stopWatchdog(pp);
       if (pp.messageResolve) {
         pp.messageResolve({ exited: true, error: err });
         pp.messageResolve = null;
@@ -777,6 +832,7 @@ class ClaudeAdapter extends BaseAdapter {
     pp.hasToolUseSinceLastText = false;
     pp.postedThinking = false;
     pp.everPostedAnything = false;
+    pp.awaitingToolResult = false;
 
     const stdinMsg = JSON.stringify({
       type: 'user',
@@ -787,11 +843,18 @@ class ClaudeAdapter extends BaseAdapter {
     }) + '\n';
 
     return new Promise((resolve) => {
-      pp.messageResolve = resolve;
+      pp.messageResolve = (result) => {
+        this._stopWatchdog(pp);
+        resolve(result);
+      };
+      pp.lastStdoutTime = Date.now();
+      this._startWatchdog(pp);
       try {
         pp.proc.stdin.write(stdinMsg);
       } catch (e) {
         this._log(`stdin write failed: ${e.message}`);
+        this._stopWatchdog(pp);
+        pp.messageResolve = null;
         resolve({ exited: true, error: e });
       }
     });

package/src/adapters/openclaw.js

@@ -354,22 +354,38 @@ class OpenClawAdapter extends BaseAdapter {
         } catch {}
       }, 500);
 
+      // 'error' and 'exit' can BOTH fire for a single failed spawn. Closing
+      // stderrFd twice throws EBADF from inside the event callback, which —
+      // with no daemon-level handler — used to crash the entire daemon. Guard
+      // so the fd is closed once and the promise settles once.
+      let settled = false;
+      const closeFd = () => { try { fs.closeSync(stderrFd); } catch {} };
+
       const killTimeout = setTimeout(() => {
-        proc.kill();
+        if (settled) return;
+        settled = true;
+        clearInterval(pollInterval);
+        closeFd();
+        try { fs.unlinkSync(stderrFile); } catch {}
+        try { proc.kill(); } catch {}
         reject(new Error('CLI timed out after 600 seconds'));
       }, 600000);
 
       proc.on('error', (err) => {
+        if (settled) return;
+        settled = true;
         clearInterval(pollInterval);
         clearTimeout(killTimeout);
-        fs.closeSync(stderrFd);
+        closeFd();
         try { fs.unlinkSync(stderrFile); } catch {}
         reject(err);
       });
       proc.on('exit', (code) => {
+        if (settled) return;
+        settled = true;
         clearInterval(pollInterval);
         clearTimeout(killTimeout);
-        fs.closeSync(stderrFd);
+        closeFd();
         // Read full stderr content (contains JSON output + trace lines)
         let stderrContent = '';
         try {

package/src/adapters/opencode.js

@@ -123,6 +123,22 @@ class OpenCodeAdapter extends BaseAdapter {
   // ------------------------------------------------------------------
 
   _findOpencodeBinary() {
+    const home = os.homedir();
+    const ext = IS_WINDOWS ? '.cmd' : '';
+
+    // Tier 0: Isolated runtime prefix — where the launcher installs agents
+    // (~/.openagents/runtimes/opencode/node_modules/.bin). Every other adapter
+    // checks this first; opencode was the lone exception, so a launcher-managed
+    // install was invisible unless its .bin happened to be on PATH — which is
+    // exactly why the workspace failed with "opencode CLI not found" even though
+    // the marketplace showed it installed.
+    const runtimeBin = path.join(home, '.openagents', 'runtimes', 'opencode', 'node_modules', '.bin', `opencode${ext}`);
+    if (fs.existsSync(runtimeBin)) return runtimeBin;
+
+    // Tier 0b: Legacy shared portable prefix.
+    const legacyBin = path.join(home, '.openagents', 'nodejs', 'node_modules', '.bin', `opencode${ext}`);
+    if (fs.existsSync(legacyBin)) return legacyBin;
+
     // Tier 1: PATH
     try {
       if (IS_WINDOWS) {
@@ -136,12 +152,10 @@ class OpenCodeAdapter extends BaseAdapter {
     } catch {}
 
     // Tier 2: Next to Node.js
-    const ext = IS_WINDOWS ? '.cmd' : '';
     const nearNode = path.join(path.dirname(process.execPath), `opencode${ext}`);
     if (fs.existsSync(nearNode)) return nearNode;
 
     // Tier 3: Common locations
-    const home = os.homedir();
     const candidates = IS_WINDOWS ? [
       path.join(process.env.APPDATA || '', 'npm', 'opencode.cmd'),
     ] : [

package/src/cli.js

@@ -64,9 +64,18 @@ function table(rows, headers) {
 
 async function cmdUp(connector, flags) {
   if (flags.foreground) {
-    // Run in foreground (used by daemonize child) — skip PID check
-    // because the parent already wrote our PID to the file.
+    // Run in foreground. daemonize() already guards its own child, but the
+    // launcher spawns `up --foreground` DIRECTLY — bypassing that guard — so a
+    // stale/empty pid file used to let it pile up dozens of daemons that each
+    // join the workspace as the same agents (session wars, duplicate replies).
+    // Enforce the singleton here using process-liveness from the pid OR status
+    // file, so a clobbered pid file can't defeat it.
     const daemon = connector.createDaemon();
+    const other = Daemon.runningDaemonPid(daemon.config.configDir);
+    if (other) {
+      print(`Daemon already running (PID ${other}); not starting another.`);
+      return;
+    }
     await daemon.start();
   } else {
     const pid = connector.getDaemonPid();
@@ -172,7 +181,15 @@ async function cmdRemove(connector, _flags, positional) {
 async function cmdStart(connector, _flags, positional) {
   const name = positional[0];
   if (!name) { print('Usage: agn start <name>'); return; }
-  connector.sendDaemonCommand(`restart:${name}`);
+  // `start` must be idempotent — it ensures the agent is running, it does NOT
+  // forcibly restart one that already is. Send `start:` (which the daemon
+  // guards: relaunch only when not already running) rather than `restart:`.
+  // A blind `restart:` tears down the workspace session the daemon already
+  // joined on launch and re-joins as the same agent; the server revokes the
+  // first session, so the agent stops the moment it next touches the workspace
+  // (first user message → "thinking..." then silence). The launcher already
+  // sends `start:`; this aligns the CLI with it.
+  connector.sendDaemonCommand(`start:${name}`);
   print(`Sent start command for '${name}'`);
 }
 

package/src/daemon.js

@@ -55,6 +55,25 @@ class Daemon {
       try { process.on('SIGHUP', () => this._reload()); } catch {}
     }
 
+    // Crash guards. A bug in one adapter — a rejected fire-and-forget promise,
+    // an EBADF from a double fs.closeSync in a child-process callback, a throw
+    // inside a stream/'exit' handler — must NEVER take down the whole daemon
+    // and every other agent with it. Node ≥15 terminates the process on an
+    // unhandled rejection by default, so without these the daemon silently
+    // dies and the launcher shows "Daemon stopped". Log loudly, keep
+    // supervising; per-agent failures are already isolated in _adapterLoop.
+    if (!this._crashGuardsInstalled) {
+      this._crashGuardsInstalled = true;
+      process.on('unhandledRejection', (reason) => {
+        const msg = reason && reason.stack ? reason.stack : String(reason);
+        this._log(`UNHANDLED REJECTION (daemon kept alive): ${msg}`);
+      });
+      process.on('uncaughtException', (err) => {
+        const msg = err && err.stack ? err.stack : String(err);
+        this._log(`UNCAUGHT EXCEPTION (daemon kept alive): ${msg}`);
+      });
+    }
+
     // Write PID file
     this._writePid();
 
@@ -444,7 +463,12 @@ class Daemon {
     let adapter;
     try {
       adapter = createAdapter(agentType, {
-        workspaceId: network.id,
+        // Networks created via the launcher can be persisted with id: null
+        // (the workspace service returns only a slug). The server identifies
+        // a workspace by its slug — the same value the web UI uses in its URL —
+        // so fall back to it. Joining with a null id makes every poll/heartbeat
+        // fail "Network not found", which spins the adapter in an error loop.
+        workspaceId: network.id || network.slug,
         channelName: 'general',
         token: network.token,
         agentName: name,
@@ -657,8 +681,24 @@ class Daemon {
           this.stopAgent(agentName);
         } else if (cmd.startsWith('start:')) {
           const agentName = cmd.slice(6).trim();
-          this._log(`Command: start ${agentName}`);
-          this.restartAgent(agentName);
+          // 'start' must be idempotent. The launcher sends start:<name> right
+          // after (re)spawning the daemon, but the daemon's own start() already
+          // launched every configured agent. A blind restart here tears down
+          // the just-joined workspace session and re-joins as the same agent;
+          // the server revokes the first session and the agent then stops the
+          // moment it next touches the workspace (e.g. the first user message →
+          // "thinking..." status). Only (re)launch when it isn't running.
+          const running =
+            (this._adapters && this._adapters[agentName]) ||
+            ['running', 'starting'].includes(
+              this._processes[agentName] && this._processes[agentName].state
+            );
+          if (running) {
+            this._log(`Command: start ${agentName} — already running, skipping`);
+          } else {
+            this._log(`Command: start ${agentName}`);
+            this.restartAgent(agentName);
+          }
         } else if (cmd.startsWith('restart:')) {
           const agentName = cmd.slice(8).trim();
           this._log(`Command: restart ${agentName}`);
@@ -831,6 +871,38 @@ class Daemon {
       return false;
     }
   }
+
+  /**
+   * Return the PID of another live daemon for this configDir, or null.
+   *
+   * Used to enforce the singleton even on the `up --foreground` path, which the
+   * launcher spawns directly (bypassing daemonize's guard). Trusts BOTH the pid
+   * file and the status file (a live daemon rewrites the latter every 5s with
+   * its own pid), because the pid file gets emptied/clobbered under races. Uses
+   * real process-liveness — not just file age — so a daemon that was just
+   * stopped for a legitimate restart doesn't block the replacement.
+   */
+  static runningDaemonPid(configDir) {
+    const self = process.pid;
+    const isOtherAlive = (pid) =>
+      pid && pid !== self && Daemon._isAlive(pid);
+
+    const pidFromFile = Daemon._readPid(path.join(configDir, 'daemon.pid'));
+    if (isOtherAlive(pidFromFile)) return pidFromFile;
+
+    try {
+      const statusFile = path.join(configDir, 'daemon.status.json');
+      const age = Date.now() - fs.statSync(statusFile).mtimeMs;
+      // Bound the age so a long-dead daemon whose pid got reused by an
+      // unrelated process can't masquerade as a live daemon.
+      if (age < 30000) {
+        const raw = JSON.parse(fs.readFileSync(statusFile, 'utf-8'));
+        const pid = raw && raw.pid;
+        if (isOtherAlive(pid)) return pid;
+      }
+    } catch {}
+    return null;
+  }
 }
 
 module.exports = { Daemon };

package/src/installer.js

@@ -941,7 +941,7 @@ class Installer {
     const { spawn: spawnProc } = require('child_process');
     const https = require('https');
     const os = require('os');
-    const nodeVersion = 'v22.16.0';
+    const nodeVersion = 'v22.22.3';
     const plat = Installer.platform();
 
     if (onData) onData(`Node.js not found. Installing Node.js ${nodeVersion}...\n\n`);

package/icons/swebench.svg

@@ -1 +0,0 @@
-<svg viewBox="0 0 24 24" width="1em" height="1em" xmlns="http://www.w3.org/2000/svg"><circle cx="12" cy="12" r="11" fill="#6366f1" /><text x="12" y="17" text-anchor="middle" font-family="system-ui" font-weight="700" font-size="14" fill="#fff">S</text></svg>