@openagents-org/agent-launcher 0.2.186 → 0.2.188

package/src/adapters/hermes.js

@@ -25,6 +25,7 @@ const { spawn, bridgeSpawn } = require('../wsl');
 
 const BaseAdapter = require('./base');
 const { buildOpenclawSystemPrompt } = require('./workspace-prompt');
+const { REASON } = require('./health-status');
 const { whichBinary, whereBinary } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
@@ -123,6 +124,34 @@ class HermesAdapter extends BaseAdapter {
     return null;
   }
 
+  /**
+   * Preflight gate (run by the daemon before join). Hermes can do nothing
+   * without its CLI, so when none can be resolved we surface a precise
+   * 'runtime_missing' reason and skip the workspace join — instead of joining,
+   * reporting "online" and then failing every message. That contradiction is
+   * exactly what users hit: the workspace showed a green hermes and "all set"
+   * while the smoke test on the same screen said "Not installed", because
+   * `create_agent --install` treats a failed third-party install script as a
+   * warning and connects the agent anyway.
+   *
+   * Re-resolves rather than trusting the constructor's lookup: an install that
+   * landed after the daemon started must not need a restart to be seen. NOTE:
+   * 'runtime_missing' (binary gone/never landed at run time), NOT
+   * 'not_installed' — install detection lives in the installer.
+   */
+  preflight() {
+    if (!this._hermesBin) this._hermesBin = this._findHermesBinary();
+    if (!this._hermesBin) {
+      return {
+        ok: false,
+        reason: REASON.RUNTIME_MISSING,
+        message: `Hermes CLI not found — install with: ${HERMES_INSTALL_HINT}`,
+      };
+    }
+    this._log(`Hermes CLI resolved: ${this._hermesBin}`);
+    return { ok: true };
+  }
+
   _resolveProfile(explicit, agentName) {
     if (explicit && explicit !== '' && explicit !== 'auto') return explicit;
     // Match agent name to an existing ~/.hermes/profiles/<name> if present
@@ -371,6 +400,17 @@ class HermesAdapter extends BaseAdapter {
     const sender = msg.senderName || msg.senderType || 'user';
     this._log(`Processing workspace message from ${sender} in ${msgChannel}`);
 
+    // Re-resolve per message: the constructor's lookup is a snapshot, and an
+    // agent that was created before its CLI finished installing would
+    // otherwise stay broken until the daemon restarts.
+    if (!this._hermesBin) this._hermesBin = this._findHermesBinary();
+    if (!this._hermesBin) {
+      const message = `Hermes CLI not found — install with: ${HERMES_INSTALL_HINT}`;
+      this._reportStatus(REASON.RUNTIME_MISSING, message);
+      await this.sendError(msgChannel, message);
+      return;
+    }
+
     await this._autoTitleChannel(msgChannel, content);
     await this.sendStatus(msgChannel, 'thinking...');
 

package/src/adapters/llm-direct.js

@@ -158,7 +158,8 @@ class LlmDirectAdapter extends BaseAdapter {
       'Authorization': `Bearer ${this._apiKey}`,
     };
     const payload = JSON.stringify({
-      model: this._model || 'gpt-4o',
+      // The model picked in the workspace, which modelLabel() reports, wins.
+      model: this.modelLabel() || 'gpt-4o',
       messages,
       stream: true,
     });

package/src/adapters/nanoclaw-control.js

@@ -21,6 +21,7 @@ const path = require('path');
 const { execFile, execFileSync } = require('child_process');
 
 const { redactSecrets } = require('./nanoclaw-protocol');
+const { whereAll } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
 
@@ -176,14 +177,7 @@ function looksLikeNanoclaw(dir) {
 /** Follow `ncl` on PATH back to the checkout root (bin/ncl → <root>). */
 function homeFromNclBinary() {
   try {
-    const which = IS_WINDOWS ? 'where' : 'which';
-    const out = execFileSync(which, ['ncl'], {
-      encoding: 'utf-8',
-      timeout: 5000,
-      stdio: ['ignore', 'pipe', 'ignore'],
-    })
-      .split(/\r?\n/)[0]
-      .trim();
+    const out = whichSafe('ncl');
     if (!out) return null;
     let real = out;
     try {
@@ -233,15 +227,9 @@ function findNanoclawHome(env = process.env) {
 
 function whichSafe(bin) {
   try {
-    const which = IS_WINDOWS ? 'where' : 'which';
-    const out = execFileSync(which, [bin], {
-      encoding: 'utf-8',
-      timeout: 5000,
-      stdio: ['ignore', 'pipe', 'ignore'],
-    })
-      .split(/\r?\n/)[0]
-      .trim();
-    return out || null;
+    // Walks PATH in-process: `where` prints in the OEM codepage, which
+    // mangled any non-ASCII profile path when read back as UTF-8.
+    return whereAll(bin)[0] || null;
   } catch {
     return null;
   }

package/src/adapters/openclaw.js

@@ -23,7 +23,7 @@ const { spawn } = require('../wsl');
 const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt } = require('./utils');
 const { buildOpenclawSkillMd, buildOpenclawSystemPrompt, workspaceSkillName } = require('./workspace-prompt');
-const { getRuntimePrefix } = require('../paths');
+const { getRuntimePrefix, whereBinary } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
 const OPENCLAW_STATE_DIR = path.join(
@@ -74,31 +74,17 @@ class OpenClawAdapter extends BaseAdapter {
     const mjs = path.join(portableDir, 'node_modules', 'openclaw', 'openclaw.mjs');
     if (fs.existsSync(mjs)) return mjs;
 
-    // Fallback: check if openclaw is on PATH (system install)
-    // On Windows, resolve .cmd shim to actual .mjs path to avoid spawn issues
-    try {
-      const cmd = IS_WINDOWS ? 'where openclaw.cmd' : 'which openclaw';
-      const result = execSync(cmd, { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] })
-        .split(/\r?\n/)[0].trim();
-      if (result) {
-        const resolved = this._resolveShimToMjs(result);
-        if (resolved) return resolved;
-        // On Unix, which returns the actual binary/symlink
-        if (!IS_WINDOWS) return result;
-      }
-    } catch {}
-    // Windows: also try without .cmd extension (for system installs on PATH)
-    if (IS_WINDOWS) {
-      try {
-        const result = execSync('where openclaw', { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] })
-          .split(/\r?\n/)[0].trim();
-        if (result) {
-          // Try the .cmd variant of this path
-          const cmdPath = result.replace(/(?:\.cmd)?$/i, '.cmd');
-          const resolved = this._resolveShimToMjs(cmdPath);
-          if (resolved) return resolved;
-        }
-      } catch {}
+    // Fallback: a copy the user installed themselves (npm -g, nvm, a custom
+    // npm prefix). whereBinary searches the directories itself instead of
+    // shelling out to `where`, which prints in the OEM codepage and mangled
+    // any non-ASCII profile path (C:\Users\王…) past recognition.
+    const found = whereBinary('openclaw');
+    if (found) {
+      // Windows: resolve the .cmd shim to openclaw.mjs to avoid spawn issues.
+      // Unix: `which` hands back the binary or its symlink, either runs as is.
+      const resolved = this._resolveShimToMjs(found);
+      if (resolved) return resolved;
+      if (!IS_WINDOWS) return found;
     }
     return null;
   }
@@ -359,13 +345,7 @@ class OpenClawAdapter extends BaseAdapter {
       // Unified path first (symlink on Unix), then legacy bin/ fallback, then system node
       const nodeUnified = path.join(portableDir, IS_WINDOWS ? 'node.exe' : 'node');
       let nodeBin = fs.existsSync(nodeUnified) ? nodeUnified : path.join(portableDir, 'bin', 'node');
-      if (!fs.existsSync(nodeBin)) {
-        try {
-          const cmd = IS_WINDOWS ? 'where node.exe' : 'which node';
-          nodeBin = execSync(cmd, { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] })
-            .split(/\r?\n/)[0].trim();
-        } catch { nodeBin = 'node'; }
-      }
+      if (!fs.existsSync(nodeBin)) nodeBin = whereBinary('node') || 'node';
 
       // binary from _findOpenclawBinary() is already resolved to .mjs when possible
       let spawnBin, spawnArgs;

package/src/adapters/utils.js

@@ -88,19 +88,22 @@ function formatAttachmentsForPrompt(
       const url = att.url || `${base}/v1/files/${fileId}`;
       const curl = isWindows ? 'curl.exe' : 'curl';
       const tmpDir = isWindows ? '$env:TEMP' : '/tmp';
+      // A web upload's filename is its workspace path (uploaded_files/<stamp>_<name>)
+      // and curl -o does not create folders, so that download failed with exit 23.
+      const localName = filename.split(/[\\/]/).pop() || fileId || 'attachment';
       if (contentType.startsWith('image/')) {
         lines.push(
           `- Image: ${filename} (file_id: ${fileId}) — ` +
           `download with curl, then use your Read tool on the local file to view it:\n` +
-          `  Step 1: ${curl} -s -H "X-Workspace-Token: ${tokenExpr}" "${url}" -o ${tmpDir}/${filename}\n` +
-          `  Step 2: Use the Read tool on ${tmpDir}/${filename} to see the image`
+          `  Step 1: ${curl} -s -H "X-Workspace-Token: ${tokenExpr}" "${url}" -o ${tmpDir}/${localName}\n` +
+          `  Step 2: Use the Read tool on ${tmpDir}/${localName} to see the image`
         );
       } else {
         lines.push(
           `- File: ${filename} (file_id: ${fileId}, type: ${contentType}) — ` +
           `download with curl, then use your Read tool on the local file:\n` +
-          `  Step 1: ${curl} -s -H "X-Workspace-Token: ${tokenExpr}" "${url}" -o ${tmpDir}/${filename}\n` +
-          `  Step 2: Use the Read tool on ${tmpDir}/${filename} to read the file`
+          `  Step 1: ${curl} -s -H "X-Workspace-Token: ${tokenExpr}" "${url}" -o ${tmpDir}/${localName}\n` +
+          `  Step 2: Use the Read tool on ${tmpDir}/${localName} to read the file`
         );
       }
     } else {

package/src/daemon.js

@@ -9,6 +9,7 @@ const { execSync, execFileSync } = require('child_process');
 const { spawn } = require('./wsl');
 const os = require('os');
 const { WorkspaceClient } = require('./workspace-client');
+const { listEndpointModels } = require('./model-list');
 const { getEnhancedEnv, whichBinary, IS_WINDOWS, defaultAgentWorkdir } = require('./paths');
 
 /**
@@ -44,6 +45,23 @@ function filesystemRoots(platform = os.platform(), exists = fs.existsSync) {
   return roots;
 }
 
+/**
+ * Hostname of a configured base URL, or null when there is none. The roster
+ * carries only this: a relay URL can hold a credential in its userinfo or
+ * path. A value written without a scheme (`localhost:4000`) still names a host.
+ */
+function endpointHost(value) {
+  const raw = String(value || '').trim();
+  if (!raw) return null;
+  for (const candidate of [raw, `http://${raw}`]) {
+    try {
+      const host = new URL(candidate).hostname.toLowerCase();
+      if (host) return host;
+    } catch {}
+  }
+  return null;
+}
+
 /**
  * Agent process lifecycle manager.
  *
@@ -326,7 +344,8 @@ class Daemon {
         // Model/key: per-agent env override, else the type-level saved env.
         // Both power the workspace agent cards; the key goes out MASKED only,
         // so the edit form can show a key is configured without the secret
-        // ever leaving the device.
+        // ever leaving the device. The endpoint goes out as a hostname, so
+        // the workspace can tell a relay from the vendor its model list is for.
         let typeEnv = {};
         try { typeEnv = this.envManager.load(a.type) || {}; } catch {}
         const model = (a.env && a.env.LLM_MODEL) || typeEnv.LLM_MODEL || null;
@@ -338,6 +357,7 @@ class Daemon {
           model: model || null,
           workingDir: a.path || null,
           apiKeyMasked: apiKey ? maskApiKey(apiKey) : null,
+          baseUrlHost: endpointHost(this._configuredBaseUrl(a, typeEnv)),
           probe: this._probes[a.name] || null,
         });
       }
@@ -347,6 +367,52 @@ class Daemon {
     return roster;
   }
 
+  /**
+   * The base URL this agent's CLI is pointed at, found the way _buildAgentEnv
+   * builds its env: LLM_BASE_URL or a provider variable (OPENAI_BASE_URL,
+   * ANTHROPIC_BASE_URL, …) saved for it or mapped by resolve_env, and failing
+   * those, the daemon's own environment for the provider variable this type's
+   * LLM_BASE_URL maps to, which the spawned CLI inherits.
+   */
+  _configuredBaseUrl(a, typeEnv) {
+    const saved = { ...typeEnv, ...(a.env || {}) };
+    let env = saved;
+    try { env = { ...saved, ...this.envManager.resolve(a.type, saved, this.registry) }; } catch {}
+    const set = (v) => String(v || '').trim();
+    if (set(env.LLM_BASE_URL)) return env.LLM_BASE_URL;
+    const key = Object.keys(env).find((k) => /_BASE_URL$/.test(k) && set(env[k]));
+    if (key) return env[key];
+    let rules = [];
+    try { rules = (this.registry && this.registry.getResolveRules(a.type)) || []; } catch {}
+    const inherited = rules.find((r) => r && r.from === 'LLM_BASE_URL' && r.to && set(process.env[r.to]));
+    return inherited ? process.env[inherited.to] : null;
+  }
+
+  /**
+   * Where this agent's CLI sends requests and with which key, for listing that
+   * endpoint's models. The key is looked up the way the CLI would find it: the
+   * protocol's own variables for an Anthropic-protocol agent, else LLM_API_KEY
+   * or the variable resolve_env maps it to, inherited from the daemon or not.
+   */
+  _agentEndpoint(a) {
+    let typeEnv = {};
+    try { typeEnv = this.envManager.load(a.type) || {}; } catch {}
+    const env = this._buildAgentEnv(a);
+    let entry = null;
+    try { entry = this.registry.getEntry(a.type); } catch {}
+    const protocol = (entry && entry.protocol) || 'openai';
+    const rules = (entry && entry.resolve_env && entry.resolve_env.rules) || [];
+    const keyVars = protocol === 'anthropic'
+      ? ['ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_API_KEY', 'LLM_API_KEY']
+      : ['LLM_API_KEY', ...rules.filter((r) => r && r.from === 'LLM_API_KEY').map((r) => r.to), 'OPENAI_API_KEY'];
+    const keyVar = keyVars.find((k) => k && String(env[k] || '').trim());
+    return {
+      baseUrl: this._configuredBaseUrl(a, typeEnv),
+      apiKey: keyVar ? String(env[keyVar]).trim() : '',
+      protocol,
+    };
+  }
+
   /**
    * Filesystem hint for the working-directory picker: home, its immediate
    * (non-hidden) subfolders, and the device's filesystem roots. Roots let a
@@ -606,6 +672,20 @@ async _runNodeCommand(n, cmd) {
         this._nodeHeartbeat();
         ok = true;
         message = `Detected ${this._runtimes.length} runtime(s)`;
+      } else if (action === 'list_models') {
+        // The model picker asks what the agent's own endpoint serves. The
+        // request needs the key, which is why it runs here.
+        if (!name) throw new Error('Missing agent name');
+        const agent = this.config.getAgent(name);
+        if (!agent || !this._agentOnNodeWorkspace(agent, n)) {
+          throw new Error(`Agent '${name}' is not managed by this workspace`);
+        }
+        const endpoint = this._agentEndpoint(agent);
+        if (!endpoint.baseUrl) throw new Error(`Agent '${name}' uses its CLI's default endpoint`);
+        const listed = await listEndpointModels(endpoint);
+        ok = listed.models.length > 0;
+        message = ok ? `Listed ${listed.models.length} model(s)` : listed.error;
+        data = { models: listed.models };
       } else if (action === 'list_dir') {
         data = this._listDir(args.path);
         ok = true;