@openagents-org/agent-launcher 0.2.182 → 0.2.184

package/src/adapters/opencode.js

@@ -114,12 +114,54 @@ class OpenCodeAdapter extends BaseAdapter {
 
     this._opencodeBinary = this._findOpencodeBinary();
     if (this._opencodeBinary) {
-      this._log(`Using OpenCode subprocess mode: ${this._opencodeBinary}`);
+      this._log(`Using ${this._cliLabel()} subprocess mode: ${this._opencodeBinary}`);
     } else {
-      this._log(`OpenCode binary not found. Install with: npm install -g opencode-ai@${OPENCODE_PINNED_VERSION}`);
+      this._log(`${this._cliLabel()} binary not found. ${this._installHint()}`);
     }
   }
 
+  // ------------------------------------------------------------------
+  // What differs between OpenCode and the CLIs built on it
+  // ------------------------------------------------------------------
+  //
+  // Vendors ship their own agents on top of OpenCode (Huawei's CodeArts Agent
+  // is one — see codearts.js). They keep its `run --format json` stream, its
+  // sessions and its failure shapes, and change how the CLI is found, launched
+  // and authenticated. These hooks are exactly that difference.
+
+  /** Product name used in logs and user-facing errors. */
+  _cliLabel() {
+    return 'OpenCode';
+  }
+
+  _installHint() {
+    return `Install with: npm install -g opencode-ai@${OPENCODE_PINNED_VERSION}`;
+  }
+
+  /** User-facing message per failure category. */
+  _failureMessages() {
+    return FAILURE_MESSAGES;
+  }
+
+  /** Whether a run may not start without a model (OpenCode hangs without one). */
+  _modelRequired() {
+    return true;
+  }
+
+  /** Arguments after the binary for one `run`. */
+  _buildRunArgs({ runCwd, model, sessionId }) {
+    // Preflight guarantees a resolvable model; pin it explicitly — without it
+    // opencode hangs waiting for interactive provider/model selection.
+    const args = ['run', '--format', 'json', '--dir', runCwd, '--model', model];
+    if (sessionId) args.push('--session', sessionId);
+    return args;
+  }
+
+  /** Environment the CLI is spawned with. */
+  _spawnEnv() {
+    return { ...(this.agentEnv || process.env) };
+  }
+
   /**
    * Migrate sessions file from old location to agent home.
    */
@@ -793,30 +835,25 @@ class OpenCodeAdapter extends BaseAdapter {
     try { this._ensureCustomProviderConfig(runCwd); } catch (e) {
       this._log(`Gateway provider config failed (continuing): ${e.message}`);
     }
-    const cmd = [binary, 'run', '--format', 'json', '--dir', runCwd];
-
-    // Preflight guarantees a resolvable model; pin it explicitly — without it
-    // opencode hangs waiting for interactive provider/model selection.
     const model = this._resolveModel();
-    cmd.push('--model', model);
-
     const sessionId = this._channelSessions[msgChannel];
+    const args = this._buildRunArgs({ runCwd, model, sessionId });
+
     let fullPrompt;
     if (sessionId) {
       fullPrompt = content;
-      cmd.push('--session', sessionId);
     } else {
       this._ensureWorkspaceSkill(msgChannel);
       const context = this._buildSystemContext(msgChannel);
       fullPrompt = `${context}\n\n---\n\n${content}`;
     }
 
-    this._log(`CLI: ${binary} run --format json --dir ${runCwd} --model ${model || '(none)'}`);
+    this._log(`CLI: ${binary} ${args.join(' ')}`);
 
-    const spawnEnv = { ...(this.agentEnv || process.env) };
+    const spawnEnv = this._spawnEnv();
 
-    let spawnBinary = cmd[0];
-    let spawnArgs = cmd.slice(1);
+    let spawnBinary = binary;
+    let spawnArgs = args;
     // Only the npm `.cmd` shim needs a cmd.exe host. The native opencode.exe
     // (preferred by _findOpencodeBinary) is spawned directly — no console host.
     if (IS_WINDOWS && spawnBinary.toLowerCase().endsWith('.cmd')) {
@@ -905,7 +942,7 @@ class OpenCodeAdapter extends BaseAdapter {
 
         if (signal) {
           this._log(`opencode killed by signal ${signal} after ${TIMEOUT_MS / 1000}s (output: ${!!stdout})`);
-          const cls = OpenCodeAdapter._classifyFailure({ code, signal, stdout, stderr, stdoutErr });
+          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')
@@ -914,14 +951,14 @@ class OpenCodeAdapter extends BaseAdapter {
         }
 
         if (code !== 0) {
-          const cls = OpenCodeAdapter._classifyFailure({ code, signal, stdout, stderr, stdoutErr });
+          const cls = this.constructor._classifyFailure({ code, signal, stdout, stderr, stdoutErr });
           this._log(`opencode exited code ${code} → [${cls.category}]: ${OpenCodeAdapter._redact(cls.diagnostic).slice(0, 300)}`);
           return finish(reject, this._failure(cls.category, cls.diagnostic, cls.detail));
         }
 
         // Exit 0.
         if (stdout) this._persistSessionId(msgChannel, stdout);
-        const outcome = OpenCodeAdapter._outcomeForCleanExit({ stdout, stderr, stdoutErr, responseState });
+        const outcome = this.constructor._outcomeForCleanExit({ stdout, stderr, stdoutErr, responseState });
         if (outcome.text) return finish(resolve, outcome.text);
         const f = outcome.failure;
         this._log(`opencode exit 0 → [${f.category}]: ${OpenCodeAdapter._redact(f.diagnostic).slice(0, 300)}`);
@@ -951,7 +988,7 @@ class OpenCodeAdapter extends BaseAdapter {
 
     if (endedOnTool) {
       if (stdoutErr) {
-        const cls = OpenCodeAdapter._classifyFailure({ code: 0, signal: null, stdout, stderr, stdoutErr });
+        const cls = this._classifyFailure({ code: 0, signal: null, stdout, stderr, stdoutErr });
         const vague = ['unknown_error', 'process_crashed', 'empty_response'].includes(cls.category);
         return {
           failure: {
@@ -977,7 +1014,7 @@ class OpenCodeAdapter extends BaseAdapter {
     // provider — it can be a structured error on stdout, an incomplete
     // stream, or a genuinely empty completion. Classify rather than guess.
     if (stdoutErr) {
-      const cls = OpenCodeAdapter._classifyFailure({ code: 0, signal: null, stdout, stderr, stdoutErr });
+      const cls = this._classifyFailure({ code: 0, signal: null, stdout, stderr, stdoutErr });
       return { failure: { category: cls.category, diagnostic: `exit 0 with error event: ${cls.diagnostic || ''}`, detail: cls.detail } };
     }
     const emptyCat = OpenCodeAdapter._emptyExitCategory(stdout);
@@ -1010,7 +1047,7 @@ class OpenCodeAdapter extends BaseAdapter {
     if (!probe.executable) {
       return { ok: false, category: 'cli_not_executable', diagnostic: 'opencode --version did not run' };
     }
-    const vclass = OpenCodeAdapter._classifyVersion(probe.version);
+    const vclass = this.constructor._classifyVersion(probe.version);
     if (vclass === 'unsupported') {
       return {
         ok: false,
@@ -1022,7 +1059,7 @@ class OpenCodeAdapter extends BaseAdapter {
     // 'unknown' (unparseable) and 'degraded' (newer than tested) still run.
 
     const model = this._resolveModel();
-    if (!model) return { ok: false, category: 'model_missing' };
+    if (!model && this._modelRequired()) return { ok: false, category: 'model_missing' };
 
     const cred = this._credentialState();
     if (cred === 'missing') return { ok: false, category: 'credential_missing' };
@@ -1105,6 +1142,14 @@ class OpenCodeAdapter extends BaseAdapter {
     ];
     if (stores.some(fileNonEmpty)) return 'present';
 
+    // A model on a provider OpenCode sets up for itself is not ours to judge:
+    // OpenCode Zen's `opencode/…` free models need no sign-in at all, and any
+    // provider id other than openai/anthropic comes from OpenCode's own config.
+    // Blocking those would refuse a run the CLI can make.
+    const model = val('OPENCODE_MODEL') || val('LLM_MODEL');
+    const provider = model.includes('/') ? model.split('/')[0].toLowerCase() : '';
+    if (provider && provider !== 'openai' && provider !== 'anthropic') return 'unknown';
+
     if (val('OPENAI_BASE_URL') || val('LLM_BASE_URL')) return 'unknown';
     if (Object.keys(env).some((k) => /(_API_KEY|_API_TOKEN|_TOKEN)$/.test(k) && val(k))) return 'unknown';
     return 'missing';
@@ -1132,10 +1177,12 @@ class OpenCodeAdapter extends BaseAdapter {
    * normal reply. Carries `error_category` in metadata so the UI can route it.
    */
   async _sendClassifiedError(channel, category, detail) {
-    const base = FAILURE_MESSAGES[category] || FAILURE_MESSAGES.unknown_error;
+    const messages = this._failureMessages();
+    const base = messages[category] || messages.unknown_error;
     const safe = detail ? OpenCodeAdapter._redact(detail).trim() : '';
     const body = safe ? `${base}\n\n> ${safe}` : base;
-    const headline = category === 'incomplete_run' ? 'OpenCode stopped mid-task' : "OpenCode couldn't run";
+    const label = this._cliLabel();
+    const headline = category === 'incomplete_run' ? `${label} stopped mid-task` : `${label} couldn't run`;
     const content = `⚠️ **${headline}** — ${body}`;
     try {
       await this.client.sendMessage(this.workspaceId, channel, this.token, content, {

package/src/daemon.js

@@ -369,11 +369,32 @@ class Daemon {
    */
   async _setModelEnv(type, model) {
     const val = String(model || '');
-    const nativeVar = { claude: 'ANTHROPIC_MODEL', gemini: 'GEMINI_MODEL' }[type];
     await this._runAgn(['env', type, '--set', `LLM_MODEL=${val}`]);
+    const nativeVar = { claude: 'ANTHROPIC_MODEL', gemini: 'GEMINI_MODEL' }[type] || this._nativeModelVar(type);
     if (nativeVar) await this._runAgn(['env', type, '--set', `${nativeVar}=${val}`]);
   }
 
+  /**
+   * The agent's own model setting, for a type whose registry declares one and
+   * does not map LLM_MODEL onto anything itself (CodeArts reads CODEARTS_MODEL
+   * and nothing else). A type with a resolve_env rule for LLM_MODEL already
+   * gets there through env resolution, so it is left alone.
+   */
+  _nativeModelVar(type) {
+    try {
+      const entry = this.registry.getEntry(type);
+      if (!entry) return null;
+      const rules = (entry.resolve_env && entry.resolve_env.rules) || [];
+      if (rules.some((r) => r && r.from === 'LLM_MODEL')) return null;
+      const field = (entry.env_config || []).find(
+        (f) => f && /_MODEL$/.test(f.name || '') && f.name !== 'LLM_MODEL',
+      );
+      return field ? field.name : null;
+    } catch {
+      return null;
+    }
+  }
+
   async _refreshRuntimes() {
     try {
       const r = await this._runAgn(['runtimes', '--json']);

package/src/installer.js

@@ -6,6 +6,7 @@ const path = require('path');
 const { execSync, exec } = require('child_process');
 const { whichBinary, getEnhancedEnv, getRuntimePrefix, clearBinaryLookupCache, aiderBinDirs, resolveBinaryInKnownDirs } = require('./paths');
 const { isWslBinary, bridgedCommandString, wslHomeUnc } = require('./wsl');
+const { canBlock } = require('./probe-mode');
 const { EnvManager } = require('./env');
 const { nodeDistUrls, installRegistry } = require('./mirrors');
 const { readinessReason, REASON } = require('./adapters/health-status');
@@ -39,6 +40,19 @@ const STALL_POLL_MS = Math.max(50, Math.min(15000, Math.floor(INSTALL_STALL_MS /
 // results are cached briefly and invalidated on install/uninstall.
 const VERSION_CACHE_TTL_MS = 60000;
 const versionCache = new Map();
+/** Version probes running in the background, by cache key. See probe-mode.js. */
+const versionRefresh = new Set();
+
+/** The version token in a `--version` output, or its first line. */
+function parseVersionOutput(raw) {
+  // The optional `-prerelease` tail is NOT decoration. An agent pinned to a
+  // preview release (`@deepseek-ai/dsh@0.1.0-rc.6`) is gated on the exact
+  // version, and dropping the suffix reported a correctly installed rc.6 as
+  // plain `0.1.0` — which then failed its own gate. Agents without a
+  // prerelease segment match exactly as before.
+  const match = raw.match(/(\d+[\d.]+\d+(?:-[0-9A-Za-z.-]+)?)/);
+  return match ? match[1] : (raw.split('\n')[0] || null);
+}
 
 /**
  * Compare two dotted version strings numerically, ignoring any pre-release /
@@ -616,15 +630,8 @@ class Installer {
     ]) {
       if (fs.existsSync(candidate)) return candidate;
     }
-    try {
-      const found = execSync(isWin ? 'where node.exe' : 'which node', {
-        encoding: 'utf-8',
-        timeout: 5000,
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: getEnhancedEnv(),
-      }).split(/\r?\n/)[0].trim();
-      if (found) return found;
-    } catch {}
+    const found = whichBinary(nodeName, { allowWsl: false });
+    if (found) return found;
     return 'node';
   }
 
@@ -636,6 +643,14 @@ class Installer {
     const cached = versionCache.get(key);
     if (cached && (Date.now() - cached.ts) < VERSION_CACHE_TTL_MS) return cached.version;
 
+    if (!canBlock()) {
+      // A node CLI's `--version` takes 0.5s+ (seconds for one inside WSL).
+      // Report the last known version — or unknown, which healthCheck already
+      // handles — and let the next check pick up the answer.
+      this._refreshVersion(key, versionCmd);
+      return cached ? cached.version : null;
+    }
+
     let version = null;
     try {
       const raw = execSync(versionCmd, {
@@ -644,19 +659,36 @@ class Installer {
         env: getEnhancedEnv(),
         timeout: 10000,
       }).trim();
-      // The optional `-prerelease` tail is NOT decoration. An agent pinned to a
-      // preview release (`@deepseek-ai/dsh@0.1.0-rc.6`) is gated on the exact
-      // version, and dropping the suffix reported a correctly installed rc.6 as
-      // plain `0.1.0` — which then failed its own gate. Agents without a
-      // prerelease segment match exactly as before.
-      const match = raw.match(/(\d+[\d.]+\d+(?:-[0-9A-Za-z.-]+)?)/);
-      version = match ? match[1] : (raw.split('\n')[0] || null);
+      version = parseVersionOutput(raw);
     } catch {}
 
     versionCache.set(key, { version, ts: Date.now() });
     return version;
   }
 
+  /** _detectVersion's probe, off the calling thread. */
+  _refreshVersion(key, versionCmd) {
+    if (versionRefresh.has(key)) return;
+    versionRefresh.add(key);
+    try {
+      const child = exec(versionCmd, {
+        encoding: 'utf-8',
+        env: getEnhancedEnv(),
+        timeout: 10000,
+        windowsHide: true,
+      }, (err, stdout) => {
+        versionRefresh.delete(key);
+        versionCache.set(key, {
+          version: err ? null : parseVersionOutput(String(stdout).trim()),
+          ts: Date.now(),
+        });
+      });
+      if (child.stdin) child.stdin.end();
+    } catch {
+      versionRefresh.delete(key);
+    }
+  }
+
   /**
    * Evaluate a registry version gate against a detected version. Generic for any
    * agent. Returns { compatible: true|false|null, minVersion, message }.