@openagents-org/agent-launcher 0.2.175 → 0.2.177

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/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/registry.js

@@ -101,7 +101,16 @@ class Registry {
         // day-old) cached remote copy, same as install.
         if (b.resolve_env) entry.resolve_env = b.resolve_env;
         if (b.install) entry.install = { ...b.install };
-        if (!entry.check_ready && b.check_ready) entry.check_ready = b.check_ready;
+        // check_ready is the auth/readiness contract of the adapter shipping in
+        // THIS core, so the bundled fields win over a remote copy that may be a
+        // release behind — the same rule as install, and for the same reason.
+        // Kimi is what proved it: the CLI rewrite added `login_command: kimi
+        // login`, but the server was still serving the API-key-only entry, and
+        // "fill it in only when absent" meant the sign-in never appeared.
+        // Spread rather than replace so anything the server adds on its own
+        // (auth_detected_labels and friends) survives.
+        if (b.check_ready)
+          entry.check_ready = { ...(entry.check_ready || {}), ...b.check_ready };
         if (!entry.launch && b.launch) entry.launch = b.launch;
         if (!entry.probe && b.probe) entry.probe = b.probe;
         // Always take featured/order/support from bundled (source of truth for ordering)
@@ -148,7 +157,8 @@ class Registry {
     const b = bundled.find((e) => e.name === agentType);
     if (b) {
       if (b.install) entry.install = { ...b.install };
-      if (!entry.check_ready && b.check_ready) entry.check_ready = b.check_ready;
+      if (b.check_ready)
+        entry.check_ready = { ...(entry.check_ready || {}), ...b.check_ready };
       if (!entry.launch && b.launch) entry.launch = b.launch;
       if (!entry.probe && b.probe) entry.probe = b.probe;
       if ((!entry.env_config || !entry.env_config.length) && b.env_config?.length) entry.env_config = b.env_config;