@openagents-org/agent-launcher 0.2.185 → 0.2.186

package/package.json

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

package/src/adapters/codebuddy.js

@@ -76,7 +76,6 @@ const IS_WINDOWS = process.platform === 'win32';
 
 // Max wall-clock for a single headless run, after which the process group is
 // killed and the turn reported as interrupted.
-const TIMEOUT_MS = 600000; // 10 minutes
 
 // Idle watchdog: with no stdout frame for this long we nudge the channel, and
 // after MAX consecutive silences we kill a run that is probably wedged.
@@ -615,7 +614,6 @@ class CodeBuddyAdapter extends BaseAdapter {
         if (settled) return;
         settled = true;
         clearInterval(watchdog);
-        clearTimeout(timeout);
         if (this._channelProcesses[channel] === proc) delete this._channelProcesses[channel];
         resolve(payload);
       };
@@ -721,12 +719,6 @@ class CodeBuddyAdapter extends BaseAdapter {
         }
       }, WATCHDOG_INTERVAL_MS);
 
-      const timeout = setTimeout(() => {
-        this._log(`Run exceeded ${TIMEOUT_MS}ms — killing`);
-        killedByWatchdog = true;
-        void this._stopProcess(proc);
-      }, TIMEOUT_MS);
-
       try {
         proc.stdin.on('error', () => {});
         proc.stdin.write(prompt, 'utf-8');

package/src/adapters/commandcode.js

@@ -71,7 +71,6 @@ const IS_WINDOWS = process.platform === 'win32';
 
 // Max wall-clock for a single headless run, after which the process group is
 // killed and the turn reported as interrupted.
-const TIMEOUT_MS = 600000; // 10 minutes
 
 // Idle watchdog: with no stdout frame for this long we nudge the channel, and
 // after MAX consecutive silences we kill a run that is probably wedged.
@@ -567,7 +566,6 @@ class CommandCodeAdapter extends BaseAdapter {
         if (settled) return;
         settled = true;
         clearInterval(watchdog);
-        clearTimeout(timeout);
         if (this._channelProcesses[channel] === proc) delete this._channelProcesses[channel];
         resolve(payload);
       };
@@ -653,12 +651,6 @@ class CommandCodeAdapter extends BaseAdapter {
         }
       }, WATCHDOG_INTERVAL_MS);
 
-      const timeout = setTimeout(() => {
-        this._log(`Run exceeded ${TIMEOUT_MS}ms — killing`);
-        killedByWatchdog = true;
-        void this._stopProcess(proc);
-      }, TIMEOUT_MS);
-
       // Feed the prompt. stdin is closed immediately: Command Code times out a
       // piped stdin after 30s of silence, so an unclosed pipe would stall.
       try {

package/src/adapters/copilot.js

@@ -76,7 +76,7 @@ const SECRET_ENV_VARS = [
 const ACT_ALLOW_TOOLS = ['shell', 'write'];
 
 // How long to wait for a turn before giving up (no output / hung CLI).
-const TURN_TIMEOUT_MS = 10 * 60 * 1000;
+const TURN_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
 
 class CopilotAdapter extends BaseAdapter {
   /**
@@ -565,10 +565,15 @@ class CopilotAdapter extends BaseAdapter {
       let pending = Promise.resolve();
       let settled = false;
 
-      const timeout = setTimeout(() => {
-        this._stopProcess(proc).catch(() => {});
-        finish({ timedOut: true, finalText: accumulatedText() });
-      }, TURN_TIMEOUT_MS);
+      let timeout = null;
+      const resetTimeout = () => {
+        if (timeout) clearTimeout(timeout);
+        timeout = setTimeout(() => {
+          this._stopProcess(proc).catch(() => {});
+          finish({ timedOut: true, finalText: accumulatedText() });
+        }, TURN_IDLE_TIMEOUT_MS);
+      };
+      resetTimeout();
 
       const finish = (summary) => {
         if (settled) return;
@@ -657,6 +662,9 @@ class CopilotAdapter extends BaseAdapter {
         }
       };
 
+      if (proc.stdout) proc.stdout.on('data', resetTimeout);
+      if (proc.stderr) proc.stderr.on('data', resetTimeout);
+
       proc.stdout.on('data', (chunk) => {
         for (const ev of parser.push(chunk)) {
           pending = pending.then(() => handle(ev)).catch(() => {});

package/src/adapters/opencode.js

@@ -27,8 +27,10 @@ const { whichBinary, whereBinary, getEnhancedEnv } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
 
-// Max wall-clock for a single `opencode run`. When it fires, Node kills the
-// child with SIGTERM, the 'close' handler sees signal='SIGTERM' / code=null.
+// Max time an `opencode run` may stay completely silent. This is deliberately
+// an IDLE timeout, not a wall-clock cap: long coding tasks routinely exceed
+// five minutes while continuing to emit text/tool events. A fixed spawn
+// timeout killed those healthy runs midway through their answer.
 const TIMEOUT_MS = 300000; // 5 minutes
 
 // Pinned OpenCode CLI version. Do NOT use @latest anywhere (registry.json /
@@ -158,6 +160,34 @@ class OpenCodeAdapter extends BaseAdapter {
   }
 
   /** Environment the CLI is spawned with. */
+
+  /** Test seam for the inactivity watchdog. */
+  _runTimeoutMs() {
+    return TIMEOUT_MS;
+  }
+
+  /**
+   * Arm a watchdog that expires only after a continuous period without CLI
+   * output. Every stdout/stderr chunk proves the process is still making
+   * progress and pushes the deadline out again.
+   */
+  _createIdleWatchdog(onTimeout) {
+    const timeoutMs = this._runTimeoutMs();
+    let timer = null;
+    let stopped = false;
+    const touch = () => {
+      if (stopped) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(onTimeout, timeoutMs);
+    };
+    const cancel = () => {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+      timer = null;
+    };
+    touch();
+    return { touch, cancel, timeoutMs };
+  }
   _spawnEnv() {
     return { ...(this.agentEnv || process.env) };
   }
@@ -701,8 +731,8 @@ class OpenCodeAdapter extends BaseAdapter {
    * CRITICAL: opencode-ai does NOT read the OPENCODE_MODEL env var. When no
    * model is given on the command line AND none is set in opencode.json, the
    * non-interactive `run` command hangs forever waiting for interactive
-   * provider/model selection — it emits zero output until the spawn timeout
-   * kills it with SIGTERM (surfaced as the misleading "exited with code null").
+   * provider/model selection — it emits zero output until the inactivity
+   * watchdog kills it with SIGTERM.
    * Passing `--model` explicitly is what makes headless runs actually work.
    */
   _resolveModel() {
@@ -843,7 +873,6 @@ class OpenCodeAdapter extends BaseAdapter {
         stdio: ['pipe', 'pipe', 'pipe'],
         env: spawnEnv,
         cwd: runCwd,
-        timeout: TIMEOUT_MS,
         detached: !IS_WINDOWS,
         // Never let a console window appear. Besides being ugly, an attached
         // console makes opencode start its interactive TUI and hang instead of
@@ -859,9 +888,16 @@ class OpenCodeAdapter extends BaseAdapter {
       let pendingEvents = Promise.resolve();
       const responseState = { finalText: '', allText: '', seenText: false };
       let settled = false;
+      let timedOut = false;
+      const watchdog = this._createIdleWatchdog(() => {
+        timedOut = true;
+        this._log(`opencode idle for ${this._runTimeoutMs() / 1000}s; terminating`);
+        this._stopProcess(proc).catch(() => {});
+      });
       const finish = (fn, arg) => {
         if (settled) return;
         settled = true;
+        watchdog.cancel();
         if (this._channelProcesses[msgChannel] === proc) {
           delete this._channelProcesses[msgChannel];
         }
@@ -870,6 +906,7 @@ class OpenCodeAdapter extends BaseAdapter {
 
       if (proc.stdout) {
         proc.stdout.on('data', (d) => {
+          watchdog.touch();
           const chunk = d.toString('utf-8');
           stdout += chunk;
           streamBuffer += chunk;
@@ -882,7 +919,10 @@ class OpenCodeAdapter extends BaseAdapter {
           }
         });
       }
-      if (proc.stderr) proc.stderr.on('data', (d) => { stderr += d; });
+      if (proc.stderr) proc.stderr.on('data', (d) => {
+        watchdog.touch();
+        stderr += d;
+      });
 
       // Send the prompt via stdin, then close it so opencode knows the message
       // is complete and never blocks waiting for more input. Guard the write:
@@ -897,9 +937,8 @@ class OpenCodeAdapter extends BaseAdapter {
 
       proc.on('error', (err) => finish(reject, err));
       // 'close' (not 'exit') fires after stdout/stderr have fully drained, so we
-      // never parse a truncated response. The handler receives (code, signal):
-      // when the spawn timeout kills the child, code is null and signal is the
-      // signal name — report that as a timeout rather than "exited with code null".
+      // never parse a truncated response. The explicit `timedOut` flag keeps a
+      // watchdog termination distinct from an external signal or crash.
       proc.on('close', async (code, signal) => {
         try { await pendingEvents; } catch {}
 
@@ -917,14 +956,18 @@ class OpenCodeAdapter extends BaseAdapter {
         // because stderr happened to be empty.
         const stdoutErr = OpenCodeAdapter._extractErrorFromStdout(stdout);
 
-        if (signal) {
-          this._log(`opencode killed by signal ${signal} after ${TIMEOUT_MS / 1000}s (output: ${!!stdout})`);
+        if (timedOut) {
+          this._log(`opencode timed out after ${watchdog.timeoutMs / 1000}s idle (output: ${!!stdout})`);
           const cls = this.constructor._classifyFailure({ code, signal, stdout, stderr, stdoutErr });
-          // A signal almost always means our own timeout fired; only override to
-          // a more specific provider error if stdout/stderr clearly show one.
           const category = (cls.category === 'unknown_error' || cls.category === 'process_crashed')
             ? 'timeout' : cls.category;
-          return finish(reject, this._failure(category, cls.diagnostic || `signal=${signal}`, cls.detail));
+          return finish(reject, this._failure(category, cls.diagnostic || `idle=${watchdog.timeoutMs}ms`, cls.detail));
+        }
+
+        if (signal) {
+          this._log(`opencode killed by signal ${signal} (output: ${!!stdout})`);
+          const cls = this.constructor._classifyFailure({ code, signal, stdout, stderr, stdoutErr });
+          return finish(reject, this._failure(cls.category, cls.diagnostic || `signal=${signal}`, cls.detail));
         }
 
         if (code !== 0) {

package/src/adapters/openworker.js

@@ -98,7 +98,6 @@ const SERVER_READY_TIMEOUT_MS = 90000;
 const HEALTH_POLL_INTERVAL_MS = 400;
 
 // Max wall-clock for one turn, after which we interrupt and report it.
-const TURN_TIMEOUT_MS = 900000; // 15 minutes
 
 // Idle watchdog over the event stream, in the same shape the CLI adapters use.
 const WATCHDOG_INTERVAL_MS = 15000;
@@ -674,7 +673,6 @@ class OpenWorkerAdapter extends BaseAdapter {
         if (settled) return;
         settled = true;
         clearInterval(watchdog);
-        clearTimeout(timeout);
         if (this._channelSockets[channel] === socket) delete this._channelSockets[channel];
         try { socket.close(); } catch {}
         const userStopped = this._stoppingChannels.has(channel);
@@ -821,12 +819,6 @@ class OpenWorkerAdapter extends BaseAdapter {
         }
       }, WATCHDOG_INTERVAL_MS);
 
-      const timeout = setTimeout(() => {
-        this._log(`Turn exceeded ${TURN_TIMEOUT_MS}ms — interrupting`);
-        send({ type: 'interrupt' });
-        if (!error) error = 'The turn ran past its time limit and was stopped.';
-        finish({});
-      }, TURN_TIMEOUT_MS);
     });
   }