@openagents-org/agent-launcher 0.2.176 → 0.2.178

package/src/adapters/utils.js

@@ -120,8 +120,35 @@ function formatAttachmentsForPrompt(
   return lines.join('\n');
 }
 
+/**
+ * Strip secrets out of anything on its way to a log line or a channel message.
+ *
+ * Adapter diagnostics quote raw CLI output, and a CLI that fails on auth tends
+ * to echo the credential it was handed. The shapes here are the ones that
+ * actually turn up in that output; the closing catch-all takes any long opaque
+ * token the named patterns missed.
+ *
+ * Lived as a private static on two adapters before claude needed it as well —
+ * a third identical copy is one copy too many for a security-relevant rule.
+ */
+function redactSecrets(s) {
+  let out = String(s == null ? '' : s);
+  out = out
+    .replace(/\bsk-[A-Za-z0-9_-]{6,}/g, 'sk-[REDACTED]')
+    .replace(/\b(?:github_pat|gh[pousr])_[A-Za-z0-9_]{10,}/g, '[REDACTED_TOKEN]')
+    .replace(/\bxox[baprs]-[A-Za-z0-9-]{8,}/g, '[REDACTED_TOKEN]')
+    .replace(/\bAKIA[0-9A-Z]{12,}/g, '[REDACTED_KEY]')
+    .replace(/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}/g, '[REDACTED_JWT]')
+    .replace(/(authorization|api[_-]?key|x-api-key|token|bearer|secret|password|passwd)(["'\s:=]+)([^\s"',}]+)/gi,
+      (m, k, sep) => `${k}${sep}[REDACTED]`)
+    .replace(/([?&](?:api[_-]?key|key|token|access_token)=)[^&\s"']+/gi, '$1[REDACTED]')
+    .replace(/\b[A-Za-z0-9_-]{40,}\b/g, '[REDACTED]');
+  return out;
+}
+
 module.exports = {
   SESSION_DEFAULT_RE,
   generateSessionTitle,
   formatAttachmentsForPrompt,
+  redactSecrets,
 };

package/src/adapters/workspace-prompt.js

@@ -1021,6 +1021,38 @@ function buildPiSystemPrompt({ agentName, workspaceId, channelName, endpoint, to
   return identity + directive + '\n' + collab + '\n' + modePrompt + '\n' + api + '\n' + buildGuardrails();
 }
 
+/**
+ * Build the workspace briefing that seeds an OpenWorker session.
+ *
+ * Shape mirrors buildPiSystemPrompt — identity, browser directive,
+ * collaboration, mode, then the REST block — because OpenWorker reaches the
+ * workspace the same way: its own shell tool plus curl, with no MCP wiring from
+ * our side (registering an MCP server there writes into the user's global
+ * OpenWorker config, which is not ours to edit).
+ *
+ * Two differences from every other builder here, both forced by OpenWorker
+ * having no system-prompt hook at all:
+ *
+ *   - `execTool` is `run_shell`, the actual name of its shell tool. Naming a
+ *     tool the agent does not have is how a model ends up printing curl
+ *     commands as text instead of running them.
+ *   - This is prepended to the first USER message of a session rather than
+ *     installed as a system prompt. That makes it part of the persisted
+ *     conversation, so it is sent once and still in context on every later turn
+ *     — which is why it must read as a briefing, not as a system directive.
+ */
+function buildOpenWorkerSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false }) {
+  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills');
+  const directive = buildBrowserDirective(browserEnabled);
+  const collab = buildCollaborationPrompt('skills', workspaceSkillName(agentName));
+  const modePrompt = buildModePrompt(mode);
+  const api = buildApiSkillsPrompt({
+    endpoint, workspaceId, token, agentName, channelName, disabledModules, mode,
+    execTool: 'run_shell',
+  });
+  return identity + directive + '\n' + collab + '\n' + modePrompt + '\n' + api + '\n' + buildGuardrails();
+}
+
 /**
  * Build the task FILE contents for the DeepSeek Harness adapter.
  *
@@ -1223,6 +1255,7 @@ module.exports = {
   buildOpenCodeSkillMd,
   buildCommandCodeSkillMd,
   buildPiSystemPrompt,
+  buildOpenWorkerSystemPrompt,
   buildDeepSeekTaskFile,
   buildClaudeSkillMd,
   buildCursorSkillMd,

package/src/install-preflight.js

@@ -29,11 +29,10 @@
 'use strict';
 
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const { execFileSync } = require('child_process');
 
-const IS_MACOS = process.platform === 'darwin';
-
 /** Directories on PATH, minus any the caller wants skipped. */
 function pathDirs(exclude = []) {
   const raw = process.env.PATH || '';
@@ -154,30 +153,106 @@ function probeGit(deps = {}) {
 
 /**
  * How the user fixes each missing dependency, phrased for the install screen.
- * `action` is a hint the launcher UI can turn into a button; everything else
- * degrades to plain text.
+ *
+ * `action` is a hint the launcher UI can turn into a button. `summaryKey` and
+ * `alternativeKind` are the same thing for text: the launcher is translated
+ * and this package is not, so it looks up its own wording by those keys and
+ * keeps `summary` only as the fallback — which is also what the CLI and the
+ * install log print. `alternativeKind` in particular has to be carried rather
+ * than guessed: the alternative is Homebrew only on macOS, and a UI that
+ * labels every alternative "if you use Homebrew" is wrong on two of the three
+ * platforms we ship.
+ *
+ * @param {string} [platform] - seam for tests; production passes nothing.
  */
-function gitRemedy() {
-  if (IS_MACOS) {
+function gitRemedy(platform = process.platform) {
+  if (platform === 'darwin') {
     return {
       name: 'git',
       action: 'install-xcode-clt',
+      summaryKey: 'gitXcodeClt',
       summary: 'Git is required, and it comes with the Xcode Command Line Tools.',
       command: 'xcode-select --install',
       alternative: 'brew install git',
+      alternativeKind: 'homebrew',
     };
   }
   return {
     name: 'git',
     action: null,
+    summaryKey: 'git',
     summary: 'Git is required to download this agent.',
     command: 'sudo apt install git   # or dnf / pacman, per your distro',
     alternative: null,
+    alternativeKind: null,
+  };
+}
+
+/**
+ * Is `uv` on PATH?
+ *
+ * Unlike git, nothing provisions uv for us: an agent whose install command IS
+ * `uv tool install …` and whose machine has no uv gets the shell's own
+ * "command not found" buried in installer output, several seconds after
+ * pressing Install. The probe is a plain filesystem check — running `uv
+ * --version` would be the same answer at the cost of a process spawn, and uv
+ * has no shim behaviour to catch out the way macOS's /usr/bin/git does.
+ *
+ * Also checks uv's own default install location, which its installer script
+ * adds to PATH via a shell profile a running GUI/daemon never re-read.
+ */
+function probeUv(deps = {}) {
+  const platform = deps.platform || process.platform;
+  const exists = deps.exists || ((p) => fs.existsSync(p));
+  const home = deps.home || os.homedir();
+  const isWindows = platform === 'win32';
+  const search = deps.dirs || [
+    ...pathDirs(),
+    path.join(home, '.local', 'bin'),
+    path.join(home, '.cargo', 'bin'),
+    ...(isWindows ? [] : ['/opt/homebrew/bin', '/usr/local/bin']),
+  ];
+  const found = existsIn(search, 'uv', exists, isWindows);
+  return found ? { ok: true, detail: found } : { ok: false };
+}
+
+/** @param {string} [platform] - seam for tests; production passes nothing. */
+function uvRemedy(platform = process.platform) {
+  const summary = 'uv is required to install this agent (it is a Python tool).';
+
+  if (platform === 'win32') {
+    return {
+      name: 'uv',
+      action: null,
+      summaryKey: 'uv',
+      summary,
+      // Spelled out instead of a bare `irm … | iex`, because "run this in a
+      // terminal" on Windows lands in cmd.exe as often as in PowerShell, and
+      // the bare form is a syntax error there.
+      command:
+        'powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"',
+      // pipx is the obvious parallel to Homebrew, but a machine with no uv
+      // seldom has pipx either — whereas winget ships with Windows.
+      alternative: 'winget install --id=astral-sh.uv -e',
+      alternativeKind: 'winget',
+    };
+  }
+
+  const viaHomebrew = platform === 'darwin';
+  return {
+    name: 'uv',
+    action: null,
+    summaryKey: 'uv',
+    summary,
+    command: 'curl -LsSf https://astral.sh/uv/install.sh | sh',
+    alternative: viaHomebrew ? 'brew install uv' : 'pipx install uv',
+    alternativeKind: viaHomebrew ? 'homebrew' : 'pipx',
   };
 }
 
 const PROBES = {
   git: { probe: probeGit, remedy: gitRemedy },
+  uv: { probe: probeUv, remedy: uvRemedy },
 };
 
 /**
@@ -230,4 +305,7 @@ module.exports = {
   checkInstallPrereqs,
   missingPrereqError,
   probeGit,
+  probeUv,
+  gitRemedy,
+  uvRemedy,
 };

package/src/installer.js

@@ -1805,6 +1805,22 @@ class Installer {
         } catch {}
       }
     }
+    // Where a user-level installer puts things, on every platform. uv's own
+    // `curl … | sh` (and its Windows script) install into ~/.local/bin and add
+    // it to PATH through a shell profile that a GUI-launched process never
+    // reads — so an install command that IS `uv tool install …` died with
+    // "uv: command not found" on a machine that had uv. install-preflight's
+    // probeUv already searches these two, so leaving them out here meant the
+    // pre-flight passed and the spawn it was guarding then failed.
+    // unshift, not push: the loop below PREPENDS each entry, so the first one
+    // here ends up LAST on PATH. These are a fallback for a binary nothing else
+    // provides — they must never shadow the user's own PATH or the runtime
+    // directories above.
+    extraDirs.unshift(
+      path.join(os.homedir(), '.local', 'bin'),
+      path.join(os.homedir(), '.cargo', 'bin'),
+    );
+
     // On Windows the spread above yields a "Path" key, not "PATH". Writing
     // `env.PATH` would create a duplicate key holding only extraDirs and drop
     // everything else; libuv then resolves spawned binaries against the wrong,

package/src/paths.js

@@ -58,11 +58,13 @@ function getExtraBinDirs() {
   // CLIs whose own installer script picks a directory of its own.
   _addAgentInstallerPaths(dirs);
 
-  // Aider (uv tool install) — its executable honors XDG_BIN_HOME /
+  // CLIs installed with `uv tool install` — the executable honors XDG_BIN_HOME /
   // XDG_DATA_HOME/../bin / ~/.local/bin and also always lands in the uv tools
   // venv. A GUI/daemon process won't see the installer's PATH edit, so add the
   // real install dirs explicitly (filtered to existing dirs by the caller).
+  // `coworker` is OpenWorker's distribution name — see uvToolBinDirs.
   for (const d of aiderBinDirs()) _push(dirs, d);
+  for (const d of uvToolBinDirs('coworker')) _push(dirs, d);
 
   // Also add the directory containing the current node binary
   try {
@@ -787,19 +789,23 @@ function primeBinaryLookup() {
 }
 
 /**
- * Directories where the Aider CLI executable can land, in the SAME priority the
- * official installer (aider.chat/install.{sh,ps1} → `uv tool install`) uses, so
- * detection matches reality on every platform:
+ * Directories where a `uv tool install`-ed CLI can land, in the SAME priority uv
+ * itself uses, so detection matches reality on every platform:
  *   1. $XDG_BIN_HOME
  *   2. $XDG_DATA_HOME/../bin
  *   3. ~/.local/bin              (the default uv-tool / pipx / pip --user bin)
- *   4. the uv tools venv for aider-chat (Scripts on Windows, bin on Unix) — the
+ *   4. the uv tools venv for `pkg` (Scripts on Windows, bin on Unix) — the
  *      executable always lands here on a successful `uv tool install`, even if
  *      the bin-dir copy/PATH edit didn't happen.
+ *
+ * `pkg` is the DISTRIBUTION name uv keys its tool dir by, which is not always
+ * the command name: aider's CLI is `aider` from `aider-chat`, and OpenWorker's
+ * is `openworker-server` from `coworker`.
+ *
  * Uses os.homedir()/live env so it reflects the current process (test-friendly).
  * Returns directories only; callers join the platform binary names.
  */
-function aiderBinDirs() {
+function uvToolBinDirs(pkg) {
   const home = os.homedir();
   const dirs = [];
   if (process.env.XDG_BIN_HOME) dirs.push(process.env.XDG_BIN_HOME);
@@ -808,17 +814,22 @@ function aiderBinDirs() {
   if (IS_WINDOWS) {
     const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
     const uvTools = process.env.UV_TOOL_DIR || path.join(appData, 'uv', 'tools');
-    dirs.push(path.join(uvTools, 'aider-chat', 'Scripts'));
+    dirs.push(path.join(uvTools, pkg, 'Scripts'));
     dirs.push(path.join(home, 'bin'));
   } else {
     const uvTools = process.env.UV_TOOL_DIR
       || path.join(home, '.local', 'share', 'uv', 'tools');
-    dirs.push(path.join(uvTools, 'aider-chat', 'bin'));
+    dirs.push(path.join(uvTools, pkg, 'bin'));
     dirs.push(path.join(home, 'bin'), '/usr/local/bin', '/opt/homebrew/bin');
   }
   return dirs;
 }
 
+/** Aider's CLI, installed by aider.chat/install.{sh,ps1} → `uv tool install`. */
+function aiderBinDirs() {
+  return uvToolBinDirs('aider-chat');
+}
+
 /** Executable suffixes to try for a bare binary name, per platform. */
 const BIN_EXTS = IS_WINDOWS ? ['.cmd', '.exe', '.bat', ''] : [''];
 
@@ -889,6 +900,7 @@ module.exports = {
   getCorePrefix,
   defaultAgentWorkdir,
   aiderBinDirs,
+  uvToolBinDirs,
   IS_WINDOWS,
   IS_MACOS,
   SEP,

package/src/probe.js

@@ -30,7 +30,6 @@ const { spawn } = require('child_process');
 const { getEnhancedEnv } = require('./paths');
 const { shouldUseShellForBinary } = require('./adapters/health-status');
 const { formatAuthGuidance } = require('./auth-guidance');
-const { testLLMConnection } = require('./utils');
 
 const PROBE_PROMPT = 'hi';
 const DEFAULT_TIMEOUT_MS = 90_000;
@@ -90,7 +89,10 @@ function authFlavor(entry, agentEnv) {
  */
 /** Classify an error by its OUTPUT TEXT alone; null when nothing matches. */
 function classifyOutputText(text) {
-  if (/credit balance|insufficient[_ ]?(quota|credits|funds)|payment required|\b402\b|billing/.test(text)) return CODE.OUT_OF_CREDIT;
+  // Relays word this their own way and answer 403 rather than 402, so the
+  // English-and-402 pattern alone read "out of credit" as "bad credentials"
+  // — the one misreading that sends a user to re-authenticate a working key.
+  if (/credit balance|insufficient[_ ]?(quota|credits|funds)|payment required|\b402\b|billing|quota[_ ]?exceeded|exceeded your current quota|额度|余额|欠费|余额不足/.test(text)) return CODE.OUT_OF_CREDIT;
   if (/rate[- ]?limit|too many requests|\b429\b|overloaded|\b529\b/.test(text)) return CODE.RATE_LIMITED;
   if (/enotfound|econnrefused|econnreset|etimedout|eai_again|fetch failed|socket hang up|network error|self[- ]signed certificate|unable to get local issuer/.test(text)) return CODE.NETWORK;
   if (/api key.{0,24}(not set|not found|missing)|no api key|missing api key|environment variable.{0,40}(is )?(not set|required)/.test(text)) return CODE.MISSING_API_KEY;
@@ -171,6 +173,37 @@ function buildGuidance(code, entry, agentEnv, extra = {}) {
   return lines;
 }
 
+/**
+ * Ask the model endpoint directly why an agent is not answering.
+ *
+ * Only ever used to REPLACE a verdict that explains nothing, and only when it
+ * can do better: a successful call means the endpoint is healthy and whatever
+ * ails the CLI is the CLI's own, which the caller's vaguer answer already says
+ * more honestly than "everything is fine" would. Likewise an unclassifiable
+ * error — swapping one shrug for another helps nobody.
+ */
+async function directApiVerdict(agentEnv, entry) {
+  // Required here rather than at the top so a test can stand in for it, and
+  // so a probe that never reaches this path never loads the HTTP client.
+  const { testLLMConnection } = require('./utils');
+  let res;
+  try {
+    res = await testLLMConnection(agentEnv);
+  } catch (e) {
+    res = { success: false, error: e.message };
+  }
+  if (!res || res.success) return null;
+  const code = classifyFailure(res.error, {});
+  if (code === CODE.CLI_ERROR) return null;
+  return {
+    ok: false,
+    method: 'llm_api',
+    code,
+    message: tail(res.error, OUTPUT_CAP),
+    guidance: buildGuidance(code, entry, agentEnv),
+  };
+}
+
 /** Run a CLI to completion with a hard timeout. Never rejects. */
 function runCommand(cmd, args, { env, timeoutMs, shell = false }) {
   return new Promise((resolve) => {
@@ -266,6 +299,10 @@ async function probeAgentType(connector, type, opts = {}) {
     || (entry.probe && entry.probe.timeout_s ? entry.probe.timeout_s * 1000 : DEFAULT_TIMEOUT_MS);
   const env = { ...getEnhancedEnv(), ...agentEnv };
 
+  // Hoisted above the CLI tier: a failing CLI probe consults it too (below).
+  const hasApiKey = !!(agentEnv.LLM_API_KEY || agentEnv.OPENAI_API_KEY || agentEnv.ANTHROPIC_API_KEY
+    || agentEnv.ANTHROPIC_AUTH_TOKEN || agentEnv.KIMI_API_KEY || agentEnv.MOONSHOT_API_KEY);
+
   // ── Live tier 1: the agent's own CLI, when the registry declares how ──
   const probeArgs = entry.probe && Array.isArray(entry.probe.args) ? entry.probe.args : null;
   const altCheck = entry.check_ready && entry.check_ready.alt_check;
@@ -298,6 +335,19 @@ async function probeAgentType(connector, type, opts = {}) {
         guidance: buildGuidance(code, entry, agentEnv),
       });
     }
+    // A CLI verdict is not always the true one. A relay answering 403 "out of
+    // credit" makes Claude Code retry in silence until the probe's clock runs
+    // out, and all that reaches here is a timeout with an unrelated warning on
+    // stderr — which the guidance then reads as "it may be waiting for a login
+    // prompt", sending the user to a terminal to fix something that is not
+    // broken. Where the agent carries an endpoint and a key, ask the API the
+    // same question directly: one round trip, and it says why.
+    const unexplained = code === CODE.TIMEOUT || code === CODE.CLI_ERROR || code === CODE.EMPTY_RESPONSE;
+    if (unexplained && hasApiKey) {
+      const direct = await directApiVerdict(agentEnv, entry);
+      if (direct) return done(direct);
+    }
+
     return done({
       ok: false, method: 'cli', code,
       message: tail(res.stderr || res.stdout, OUTPUT_CAP) || (res.timedOut ? 'Timed out' : `Exited with code ${res.code}`),
@@ -306,9 +356,8 @@ async function probeAgentType(connector, type, opts = {}) {
   }
 
   // ── Live tier 2: direct LLM API call for API-key agents (e.g. OpenClaw) ──
-  const hasApiKey = !!(agentEnv.LLM_API_KEY || agentEnv.OPENAI_API_KEY || agentEnv.ANTHROPIC_API_KEY
-    || agentEnv.KIMI_API_KEY || agentEnv.MOONSHOT_API_KEY);
   if (hasApiKey || (entry.install && entry.install.api_only)) {
+    const { testLLMConnection } = require('./utils');
     let res;
     try { res = await testLLMConnection(agentEnv); } catch (e) { res = { success: false, error: e.message }; }
     if (res && res.success) {

package/src/utils.js

@@ -13,12 +13,20 @@ function testLLMConnection(env) {
   const http = require('http');
 
   const hasKimiConfig = !!(env.KIMI_API_KEY || env.MOONSHOT_API_KEY || env.KIMI_BASE_URL || env.KIMI_MODEL);
-  const apiKey = env.KIMI_API_KEY || env.MOONSHOT_API_KEY || env.LLM_API_KEY || env.OPENAI_API_KEY || env.ANTHROPIC_API_KEY || '';
+  const apiKey = env.KIMI_API_KEY || env.MOONSHOT_API_KEY || env.LLM_API_KEY || env.OPENAI_API_KEY
+    || env.ANTHROPIC_AUTH_TOKEN || env.ANTHROPIC_API_KEY || '';
   if (!apiKey) return Promise.resolve({ success: false, error: 'No API key provided' });
 
   let baseUrl = (env.KIMI_BASE_URL || env.LLM_BASE_URL || env.OPENAI_BASE_URL || (hasKimiConfig ? 'https://api.moonshot.ai/v1' : 'https://api.openai.com/v1')).replace(/\/$/, '');
   const model = env.KIMI_MODEL || env.LLM_MODEL || env.OPENCLAW_MODEL || '';
-  const isAnthropic = baseUrl.includes('anthropic');
+  // An agent configured the Anthropic way is Anthropic-shaped wherever it
+  // points. Reading only the URL missed every relay whose host says nothing
+  // about the protocol it speaks — the common case for Claude Code, which is
+  // configured entirely through ANTHROPIC_* — and sent the test to OpenAI's
+  // default endpoint with an Anthropic key.
+  const hasAnthropicConfig = !hasKimiConfig && !env.LLM_API_KEY && !env.OPENAI_API_KEY
+    && !!(env.ANTHROPIC_BASE_URL || env.ANTHROPIC_MODEL || env.ANTHROPIC_AUTH_TOKEN || env.ANTHROPIC_API_KEY);
+  const isAnthropic = hasAnthropicConfig || baseUrl.includes('anthropic');
 
   if (!isAnthropic && !baseUrl.endsWith('/v1')) {
     baseUrl += '/v1';
@@ -28,14 +36,25 @@ function testLLMConnection(env) {
     let url, headers, body;
 
     if (isAnthropic) {
-      url = 'https://api.anthropic.com/v1/messages';
+      // The configured endpoint, not the official one: a relay IS the API as
+      // far as this agent is concerned, and testing api.anthropic.com would
+      // report on a service the agent never talks to.
+      const base = (env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com').replace(/\/+$/, '');
+      url = /\/v1$/.test(base) ? `${base}/messages` : `${base}/v1/messages`;
+      const token = env.ANTHROPIC_AUTH_TOKEN || env.ANTHROPIC_API_KEY || apiKey;
       headers = {
-        'x-api-key': apiKey,
+        'x-api-key': token,
         'anthropic-version': '2023-06-01',
         'content-type': 'application/json',
       };
+      // Relays are split on which header they read, and Claude Code itself
+      // sends the bearer when pointed at one. Only off the official host: the
+      // real API has no use for it.
+      if (!/api\.anthropic\.com$/.test(new URL(url).hostname)) {
+        headers['authorization'] = `Bearer ${token}`;
+      }
       body = JSON.stringify({
-        model: model || 'claude-sonnet-4-20250514',
+        model: env.ANTHROPIC_MODEL || model || 'claude-sonnet-4-20250514',
         max_tokens: 32,
         messages: [{ role: 'user', content: 'Say hi in 5 words.' }],
       });