@openagents-org/agent-launcher 0.2.138 → 0.2.139

package/package.json

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

package/src/adapters/claude.js

@@ -710,6 +710,7 @@ class ClaudeAdapter extends BaseAdapter {
       messageResolve: null,
       msgChannel: channel,
       lastResponseText: [],
+      lastErrorText: '',
       hasToolUseSinceLastText: false,
       postedThinking: false,
       everPostedAnything: false,
@@ -783,7 +784,12 @@ class ClaudeAdapter extends BaseAdapter {
           this._saveSessions();
         }
         if (event.is_error) {
-          this._log(`Claude error: ${String(event.result || '').slice(0, 200)}`);
+          // Capture the error so _handleMessage can surface it to the user.
+          // Without this, an auth/API failure (e.g. 401 invalid token) is only
+          // logged and the user just sees "No response generated", hiding the
+          // real cause and making it nearly impossible to diagnose.
+          pp.lastErrorText = String(event.result || '').trim();
+          this._log(`Claude error: ${pp.lastErrorText.slice(0, 200)}`);
         }
         if (pp.messageResolve) {
           pp.messageResolve({ resultEvent: event });
@@ -847,6 +853,7 @@ class ClaudeAdapter extends BaseAdapter {
    */
   _sendToPersistentProc(pp, content) {
     pp.lastResponseText = [];
+    pp.lastErrorText = '';
     pp.hasToolUseSinceLastText = false;
     pp.postedThinking = false;
     pp.everPostedAnything = false;
@@ -878,6 +885,20 @@ class ClaudeAdapter extends BaseAdapter {
     });
   }
 
+  /**
+   * Turn a raw Claude `result` error into a user-facing message. Auth failures
+   * (401 / invalid token) are the most common real-world cause and are otherwise
+   * invisible — add a concrete hint about which env vars to check.
+   */
+  _formatClaudeError(text) {
+    const msg = String(text || '').trim() || 'Claude returned an error.';
+    if (/401|403|authenticate|invalid.*(token|key|api)|无效的?\s*(令牌|密钥|key)/i.test(msg)) {
+      return `Claude authentication failed: ${msg}\n\n` +
+        'Check this agent\'s API key and Base URL in the launcher — the key may be invalid or expired.';
+    }
+    return `Claude error: ${msg}`;
+  }
+
   async _handleMessage(msg) {
     let content = (msg.content || '').trim();
     const attachments = msg.attachments || [];
@@ -933,6 +954,8 @@ class ClaudeAdapter extends BaseAdapter {
         const fullResponse = existingPP.lastResponseText.join('\n').trim();
         if (fullResponse) {
           try { await this.sendResponse(msgChannel, fullResponse); } catch {}
+        } else if (existingPP.lastErrorText) {
+          try { await this.sendError(msgChannel, this._formatClaudeError(existingPP.lastErrorText)); } catch {}
         }
         this._resetIdleTimer(msgChannel);
         if (!msg._todoNudge) {
@@ -1017,7 +1040,11 @@ class ClaudeAdapter extends BaseAdapter {
             continue;
           }
           if (!pp.everPostedAnything) {
-            try { await this.sendResponse(msgChannel, 'No response generated. Please try again.'); } catch {}
+            if (pp.lastErrorText) {
+              try { await this.sendError(msgChannel, this._formatClaudeError(pp.lastErrorText)); } catch {}
+            } else {
+              try { await this.sendResponse(msgChannel, 'No response generated. Please try again.'); } catch {}
+            }
           }
           break;
         }
@@ -1052,6 +1079,10 @@ class ClaudeAdapter extends BaseAdapter {
 
         if (finalResponse) {
           try { await this.sendResponse(msgChannel, finalResponse); } catch {}
+        } else if (pp.lastErrorText) {
+          // Claude finished with an error and no assistant text (e.g. 401 invalid
+          // token). Surface it instead of silently dropping the turn.
+          try { await this.sendError(msgChannel, this._formatClaudeError(pp.lastErrorText)); } catch {}
         }
 
         this._resetIdleTimer(msgChannel);

package/src/adapters/opencode.js

@@ -22,6 +22,10 @@ const { whichBinary, 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.
+const TIMEOUT_MS = 300000; // 5 minutes
+
 class OpenCodeAdapter extends BaseAdapter {
   /**
    * @param {object} opts - BaseAdapter opts plus:
@@ -360,6 +364,32 @@ class OpenCodeAdapter extends BaseAdapter {
   // Subprocess execution
   // ------------------------------------------------------------------
 
+  /**
+   * Build the `--model` value (provider/model) for `opencode run`.
+   *
+   * 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").
+   * Passing `--model` explicitly is what makes headless runs actually work.
+   */
+  _resolveModel() {
+    const env = this.agentEnv || process.env;
+    const model = (env.OPENCODE_MODEL || env.LLM_MODEL || '').trim();
+    if (!model) return '';
+    // Already provider-qualified (e.g. "openai/gpt-4o", "anthropic/claude-…").
+    if (model.includes('/')) return model;
+    // Infer the provider from which key/base URL the env resolved to. The
+    // registry maps LLM_* → OPENAI_* for OpenAI-compatible endpoints, so
+    // "openai" is the right default; only switch for an Anthropic endpoint.
+    const baseUrl = (env.OPENAI_BASE_URL || env.LLM_BASE_URL || '').toLowerCase();
+    const provider = (env.ANTHROPIC_API_KEY || baseUrl.includes('anthropic'))
+      ? 'anthropic'
+      : 'openai';
+    return `${provider}/${model}`;
+  }
+
   _runOpencode(content, msgChannel) {
     const binary = this._opencodeBinary || this._findOpencodeBinary();
     if (binary) this._opencodeBinary = binary;
@@ -371,6 +401,19 @@ class OpenCodeAdapter extends BaseAdapter {
 
     const cmd = [binary, 'run', '--format', 'json', '--dir', this.agentHome];
 
+    // Pin the model explicitly — without it opencode hangs waiting for
+    // interactive selection (see _resolveModel). Harmless when resuming a
+    // session (opencode keeps the session's model); essential for new ones.
+    const model = this._resolveModel();
+    if (model) {
+      cmd.push('--model', model);
+    } else {
+      this._log(
+        'WARNING: no model configured (set LLM_MODEL / OPENCODE_MODEL). ' +
+        'opencode may hang or produce no response.'
+      );
+    }
+
     const sessionId = this._channelSessions[msgChannel];
     let fullPrompt;
     if (sessionId) {
@@ -382,7 +425,7 @@ class OpenCodeAdapter extends BaseAdapter {
       fullPrompt = `${context}\n\n---\n\n${content}`;
     }
 
-    this._log(`CLI: ${binary} ${cmd.slice(1, 5).join(' ')} ...`);
+    this._log(`CLI: ${binary} run --format json --dir … --model ${model || '(none)'}`);
 
     const spawnEnv = { ...(this.agentEnv || process.env) };
 
@@ -400,7 +443,7 @@ class OpenCodeAdapter extends BaseAdapter {
         stdio: ['pipe', 'pipe', 'pipe'],
         env: spawnEnv,
         cwd: this.agentHome,
-        timeout: 300000, // 5 minutes
+        timeout: TIMEOUT_MS,
         // Never let a console window appear. Besides being ugly, an attached
         // console makes opencode start its interactive TUI and hang instead of
         // running headless — the root cause of "stuck on thinking…" on Windows.
@@ -428,11 +471,22 @@ 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.
-      proc.on('close', (code) => {
+      // 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".
+      proc.on('close', (code, signal) => {
         stdout = stdout.trim();
         stderr = stderr.trim();
 
+        if (signal) {
+          this._log(`opencode killed by signal ${signal} after ${TIMEOUT_MS / 1000}s (no output: ${!stdout})`);
+          return finish(reject, new Error(
+            stderr ? stderr.slice(0, 500)
+              : `opencode timed out after ${TIMEOUT_MS / 1000}s with no response. ` +
+                'This usually means no model/provider is configured — check LLM_MODEL / LLM_API_KEY.'
+          ));
+        }
+
         if (code !== 0) {
           this._log(`opencode exited with code ${code}: ${stderr.slice(0, 300)}`);
           // Surface the real failure instead of a generic "No response" so the