@openagents-org/agent-launcher 0.2.168 → 0.2.170

package/src/adapters/index.js

@@ -21,6 +21,7 @@ const ClineAdapter = require('./cline');
 const AmpAdapter = require('./amp');
 const MiniSweAgentAdapter = require('./mini');
 const PiAdapter = require('./pi');
+const DeepSeekAdapter = require('./deepseek');
 
 const ADAPTER_MAP = {
   openclaw: OpenClawAdapter,
@@ -39,11 +40,12 @@ const ADAPTER_MAP = {
   amp: AmpAdapter,
   'mini-swe-agent': MiniSweAgentAdapter,
   pi: PiAdapter,
+  deepseek: DeepSeekAdapter,
 };
 
 /**
  * Create an adapter instance for the given agent type.
- * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes, gemini, kimi, aider, goose, copilot, cline, amp, mini-swe-agent, pi)
+ * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes, gemini, kimi, aider, goose, copilot, cline, amp, mini-swe-agent, pi, deepseek)
  * @param {object} opts - Adapter constructor options
  * @returns {BaseAdapter}
  */
@@ -73,6 +75,7 @@ module.exports = {
   AmpAdapter,
   MiniSweAgentAdapter,
   PiAdapter,
+  DeepSeekAdapter,
   createAdapter,
   ADAPTER_MAP,
 };

package/src/adapters/utils.js

@@ -52,11 +52,30 @@ function generateSessionTitle(message, maxWords = 6) {
 
 /**
  * Format attachment metadata into text to append to an agent prompt.
+ *
+ * `tokenExpr` is the SHELL EXPRESSION the agent should use for the workspace
+ * token, not the token itself. It defaults to `$TOKEN` for the adapters that
+ * already export the token under that name. An adapter whose prompt must never
+ * contain the literal token (deepseek writes its prompt to a file and exports
+ * OPENAGENTS_WORKSPACE_TOKEN into the child environment) passes its own
+ * expression instead — otherwise `$TOKEN` expands to the empty string in the
+ * child and every attachment download silently 401s.
+ *
  * @param {Array} attachments
  * @param {'mcp'|'skills'} [toolMode='mcp']
  * @param {boolean} [isWindows]
+ * @param {object} [opts]
+ * @param {string} [opts.tokenExpr='$TOKEN'] shell expression yielding the token
+ * @param {string} [opts.endpoint] base URL used when an attachment carries no
+ *   absolute `url`. Without it the fallback emits a literal `{WORKSPACE_API}`
+ *   placeholder that nothing substitutes.
  */
-function formatAttachmentsForPrompt(attachments, toolMode = 'mcp', isWindows = process.platform === 'win32') {
+function formatAttachmentsForPrompt(
+  attachments,
+  toolMode = 'mcp',
+  isWindows = process.platform === 'win32',
+  { tokenExpr = '$TOKEN', endpoint = null } = {},
+) {
   if (!attachments || attachments.length === 0) return null;
 
   const lines = ['\n[Attached files]'];
@@ -65,21 +84,22 @@ function formatAttachmentsForPrompt(attachments, toolMode = 'mcp', isWindows = p
     const fileId = att.fileId || '';
     const contentType = att.contentType || '';
     if (toolMode === 'skills') {
-      const url = att.url || `{WORKSPACE_API}/v1/files/${fileId}`;
+      const base = endpoint ? String(endpoint).replace(/\/+$/, '') : '{WORKSPACE_API}';
+      const url = att.url || `${base}/v1/files/${fileId}`;
       const curl = isWindows ? 'curl.exe' : 'curl';
       const tmpDir = isWindows ? '$env:TEMP' : '/tmp';
       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: $TOKEN" "${url}" -o ${tmpDir}/${filename}\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`
         );
       } 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: $TOKEN" "${url}" -o ${tmpDir}/${filename}\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`
         );
       }

package/src/adapters/workspace-prompt.js

@@ -1021,6 +1021,68 @@ function buildPiSystemPrompt({ agentName, workspaceId, channelName, endpoint, to
   return identity + directive + '\n' + collab + '\n' + modePrompt + '\n' + api + '\n' + buildGuardrails();
 }
 
+/**
+ * Build the task FILE contents for the DeepSeek Harness adapter.
+ *
+ * dsh takes its task as a positional argv element and has no stdin channel, so
+ * the adapter writes everything here to a private file and passes only a
+ * constant sentence on the command line. Two consequences shape this function:
+ *
+ *  - The workspace token must NEVER appear. `tokenExpr` is a SHELL EXPRESSION
+ *    (`$OPENAGENTS_WORKSPACE_TOKEN`, or `$env:OPENAGENTS_WORKSPACE_TOKEN` on
+ *    Windows) that the agent expands at run time from the child environment.
+ *    Passing the real token here would put it on disk for no benefit — and the
+ *    guard below makes that a loud failure rather than a silent leak.
+ *
+ *  - dsh has no session resume: each run is a fresh session. The channel recap
+ *    is therefore part of the task itself rather than something the agent can
+ *    be expected to remember.
+ */
+function buildDeepSeekTaskFile({
+  agentName, workspaceId, channelName, endpoint, tokenExpr,
+  mode = 'execute', disabledModules, browserEnabled = false,
+  recap = '', request = '', attachments = '',
+}) {
+  // A token expression is a shell reference, never a credential. Anything that
+  // does not start with `$` is almost certainly a real token passed by mistake.
+  if (!tokenExpr || !/^\$/.test(String(tokenExpr))) {
+    throw new Error(
+      'buildDeepSeekTaskFile: tokenExpr must be a shell expression such as '
+      + '$OPENAGENTS_WORKSPACE_TOKEN — never the workspace token itself.',
+    );
+  }
+
+  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: tokenExpr, agentName, channelName, disabledModules, mode,
+  });
+
+  const parts = [identity, directive, '\n', collab, '\n', modePrompt, '\n', api, '\n', buildGuardrails()];
+
+  if (recap) {
+    parts.push(
+      '\n## Recent channel history\n'
+      + 'You are running as a fresh process with no memory of earlier turns. '
+      + 'This is the relevant history — treat it as context, not as new work.\n\n'
+      + recap + '\n',
+    );
+  }
+
+  parts.push(
+    '\n## Your task\n'
+    + 'Respond to the request below. Everything above is context and standing '
+    + 'instruction; only this section is what you were asked to do now.\n\n'
+    + String(request || '').trim() + '\n',
+  );
+
+  if (attachments) parts.push('\n' + attachments + '\n');
+
+  return parts.join('');
+}
+
 /**
  * Build workspace skill markdown for OpenCode (written to .opencode/skills/).
  */
@@ -1127,6 +1189,7 @@ module.exports = {
   buildOpenCodeSystemPrompt,
   buildOpenCodeSkillMd,
   buildPiSystemPrompt,
+  buildDeepSeekTaskFile,
   buildClaudeSkillMd,
   buildCursorSkillMd,
 };

package/src/daemon.js

@@ -7,6 +7,18 @@ const os = require('os');
 const { WorkspaceClient } = require('./workspace-client');
 const { getEnhancedEnv, whichBinary, IS_WINDOWS, defaultAgentWorkdir } = require('./paths');
 
+/**
+ * Mask an API key for display (same shape the workspace backend uses for
+ * cloud agents): enough to recognize which key it is, never enough to use it.
+ * The partial reveal needs a real remainder to hide: first4+last4 of a
+ * 9-to-12-char key would expose most of it, so anything that short is
+ * fully masked.
+ */
+function maskApiKey(key) {
+  if (!key || key.length <= 12) return '****';
+  return key.slice(0, 4) + '...' + key.slice(-4);
+}
+
 /**
  * Agent process lifecycle manager.
  *
@@ -131,18 +143,21 @@ class Daemon {
       for (const a of this.config.getAgents()) {
         if (!this._agentOnNodeWorkspace(a, node)) continue;
         const proc = this._processes[a.name];
-        // Model: per-agent env override, else the type-level saved model. Working
-        // dir: the agent's configured path. Both power the workspace agent cards.
-        let model = (a.env && a.env.LLM_MODEL) || null;
-        if (!model) {
-          try { model = (this.envManager.load(a.type) || {}).LLM_MODEL || null; } catch { model = null; }
-        }
+        // 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.
+        let typeEnv = {};
+        try { typeEnv = this.envManager.load(a.type) || {}; } catch {}
+        const model = (a.env && a.env.LLM_MODEL) || typeEnv.LLM_MODEL || null;
+        const apiKey = (a.env && a.env.LLM_API_KEY) || typeEnv.LLM_API_KEY || null;
         roster.push({
           name: a.name,
           type: a.type || 'unknown',
           status: (proc && proc.state) || 'stopped',
           model: model || null,
           workingDir: a.path || null,
+          apiKeyMasked: apiKey ? maskApiKey(apiKey) : null,
         });
       }
     } catch {

package/src/install-preflight.js

@@ -0,0 +1,233 @@
+/**
+ * Pre-flight checks for install commands that shell out to a third-party script.
+ *
+ * `curl … | bash` installers are black boxes: whatever they decide to do about a
+ * missing dependency happens with no way for us to explain it, cancel it, or
+ * even show a useful progress line. Hermes is the case that forced this file to
+ * exist. Its install.sh needs git to clone the repo, and on a mac with no
+ * developer tools it:
+ *   1. runs `git --version`, which on macOS is a SHIM that opens the system
+ *      "The 'git' command requires the command line developer tools" dialog —
+ *      a dialog with no OpenAgents branding, appearing seconds after the user
+ *      pressed Install in our marketplace;
+ *   2. calls `xcode-select --install`, opening it a second time;
+ *   3. sleeps in a 5-second poll loop for up to 900 SECONDS waiting for git to
+ *      appear, printing one line per minute.
+ * In the launcher that reads as a progress bar frozen on "downloading" for a
+ * quarter of an hour, so users retry, which starts the whole thing again.
+ *
+ * Catching the missing dependency BEFORE spawning the installer turns all of
+ * that into one actionable message.
+ *
+ * Only dependencies with a probe below are enforced. `install.requires` is
+ * hand-maintained and partly aspirational — hermes lists python3 even though
+ * its installer provisions Python through uv when none is found — so an unknown
+ * entry is left to the installer rather than blocking an install that would
+ * have worked.
+ */
+
+'use strict';
+
+const fs = require('fs');
+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 || '';
+  return raw
+    .split(path.delimiter)
+    .map((d) => d.trim())
+    .filter((d) => d && !exclude.includes(d));
+}
+
+function existsIn(dirs, name, exists, isWindows) {
+  const names = isWindows ? [`${name}.exe`, `${name}.cmd`, name] : [name];
+  for (const dir of dirs) {
+    for (const n of names) {
+      const full = path.join(dir, n);
+      try {
+        if (exists(full)) return full;
+      } catch {
+        /* unreadable dir on PATH — skip */
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * The active developer directory, or null when none is selected. `xcode-select
+ * -p` is safe to run with no tools installed: it exits 2 and prints to stderr
+ * WITHOUT opening the install dialog. Running `git` is what opens it.
+ */
+function activeDeveloperDir() {
+  try {
+    return (
+      execFileSync('xcode-select', ['-p'], {
+        encoding: 'utf-8',
+        timeout: 5000,
+        stdio: ['ignore', 'pipe', 'ignore'],
+      }).trim() || null
+    );
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Is a REAL git available?
+ *
+ * The hard constraint on macOS: never execute `git`, and never execute
+ * `/usr/bin/git` in particular. That file exists on every mac whether or not
+ * the Command Line Tools are installed, and running it is precisely what opens
+ * the install dialog we are trying to get ahead of. So this probe only ever
+ * touches the filesystem plus `xcode-select -p`, which reports the active
+ * developer directory (exit code 2, no dialog, when there is none).
+ *
+ * Two platforms are deliberately exempt, because on them a missing git is
+ * something the installer genuinely recovers from:
+ *
+ * - **Windows.** install.ps1's Install-Git downloads PortableGit from
+ *   github.com into %LOCALAPPDATA%\hermes\git — no admin rights, no dialog, no
+ *   winget. It is slow (the script's own comment budgets five minutes) and it
+ *   can fail on a restricted network, but blocking the install would break the
+ *   many machines where it works. What Windows needs from us is a readable
+ *   error when that download fails, not a refusal — see userFacingInstallError
+ *   in the launcher.
+ * - **Linux as root.** install.sh shells out to apt/dnf/pacman, which succeeds
+ *   without a password prompt when we are already root. As a normal user the
+ *   sudo call has no tty to ask on and fails, so the refusal stands there.
+ *
+ * @param {object} [deps] - seams for tests; production passes nothing.
+ */
+function probeGit(deps = {}) {
+  const platform = deps.platform || process.platform;
+  const exists = deps.exists || ((p) => fs.existsSync(p));
+  const dirs = deps.dirs || null;
+
+  if (platform === 'win32') {
+    return { ok: true, detail: 'installer provisions PortableGit itself' };
+  }
+
+  if (platform !== 'darwin') {
+    const search = dirs || [...pathDirs(), '/usr/bin', '/usr/local/bin'];
+    const found = existsIn(search, 'git', exists, false);
+    if (found) return { ok: true, detail: found };
+    const uid = deps.uid !== undefined ? deps.uid : (process.getuid ? process.getuid() : null);
+    if (uid === 0) return { ok: true, detail: 'root can install git unattended' };
+    return { ok: false };
+  }
+
+  // A git outside /usr/bin (Homebrew, MacPorts, a manual install) is a real
+  // binary and safe to trust without running it.
+  const search = dirs || [
+    ...pathDirs(['/usr/bin']),
+    '/opt/homebrew/bin',
+    '/usr/local/bin',
+  ];
+  const found = existsIn(search, 'git', exists, false);
+  if (found) return { ok: true, detail: found };
+
+  // Otherwise the only candidate left is the /usr/bin shim, which forwards to
+  // the active developer directory. Resolve that directory and look for the git
+  // it would forward to: present means the shim works, absent means running it
+  // would open the dialog — which is exactly the case we refuse to walk into.
+  const developerDir =
+    'developerDir' in deps ? deps.developerDir : activeDeveloperDir();
+
+  const candidates = [];
+  if (developerDir) candidates.push(path.join(developerDir, 'usr', 'bin', 'git'));
+  candidates.push('/Library/Developer/CommandLineTools/usr/bin/git');
+  for (const c of candidates) {
+    try {
+      if (exists(c)) return { ok: true, detail: c };
+    } catch {
+      /* ignore */
+    }
+  }
+
+  return { ok: false };
+}
+
+/**
+ * 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.
+ */
+function gitRemedy() {
+  if (IS_MACOS) {
+    return {
+      name: 'git',
+      action: 'install-xcode-clt',
+      summary: 'Git is required, and it comes with the Xcode Command Line Tools.',
+      command: 'xcode-select --install',
+      alternative: 'brew install git',
+    };
+  }
+  return {
+    name: 'git',
+    action: null,
+    summary: 'Git is required to download this agent.',
+    command: 'sudo apt install git   # or dnf / pacman, per your distro',
+    alternative: null,
+  };
+}
+
+const PROBES = {
+  git: { probe: probeGit, remedy: gitRemedy },
+};
+
+/**
+ * Check a registry entry's `install.requires` against the machine.
+ * @returns {{ ok: boolean, missing: Array<{name: string, action: string|null, summary: string, command: string, alternative: string|null}> }}
+ */
+function checkInstallPrereqs(entry) {
+  const requires = entry && entry.install ? entry.install.requires : null;
+  if (!Array.isArray(requires) || requires.length === 0) return { ok: true, missing: [] };
+
+  const missing = [];
+  for (const name of requires) {
+    const spec = PROBES[String(name || '').toLowerCase()];
+    if (!spec) continue; // no probe → the installer's problem, not ours
+    let result;
+    try {
+      result = spec.probe();
+    } catch {
+      continue; // a probe that throws must never block an install
+    }
+    if (!result || !result.ok) missing.push(spec.remedy());
+  }
+  return { ok: missing.length === 0, missing };
+}
+
+/**
+ * The error thrown in place of running the installer. Carries `code` and
+ * `missing` so the launcher can render buttons instead of parsing prose, and a
+ * message that stands on its own for the CLI and the log.
+ */
+function missingPrereqError(agentLabel, missing) {
+  const lines = [
+    `${agentLabel} cannot be installed yet — a required tool is missing.`,
+    '',
+  ];
+  for (const item of missing) {
+    lines.push(`• ${item.summary}`);
+    lines.push(`  Install it with:  ${item.command}`);
+    if (item.alternative) lines.push(`  Or:               ${item.alternative}`);
+  }
+  lines.push('', 'Once it is installed, come back and press Install again.');
+
+  const err = new Error(lines.join('\n'));
+  err.code = 'MISSING_PREREQ';
+  err.missing = missing;
+  return err;
+}
+
+module.exports = {
+  checkInstallPrereqs,
+  missingPrereqError,
+  probeGit,
+};