@openagents-org/agent-launcher 0.2.186 → 0.2.187

package/src/model-list.js

@@ -0,0 +1,100 @@
+'use strict';
+
+/**
+ * Ask an OpenAI- or Anthropic-compatible endpoint which models it serves.
+ *
+ * The daemon answers the workspace's `list_models` command with this, so the
+ * model picker offers what the agent's relay actually has, and the key the
+ * request needs never leaves the device. Mirrors the launcher's
+ * model-catalog listOpenAiModels / listAnthropicModels.
+ */
+
+const MAX_MODELS = 300;
+
+/** The one line worth showing from an error body (relays nest it in JSON). */
+function briefError(text) {
+  try {
+    const j = JSON.parse(text);
+    const msg = typeof j.error === 'string' ? j.error : j.error && j.error.message;
+    const line = String(msg || j.message || '').trim();
+    if (line) return line.slice(0, 160);
+  } catch {}
+  return String(text || '').trim().slice(0, 160);
+}
+
+function isOfficialAnthropic(url) {
+  return url.hostname.toLowerCase() === 'api.anthropic.com';
+}
+
+/** `{data: [...]}`, a bare array, or a relay's `{models: [...]}`; ids deduped and sorted. */
+function parseModels(text) {
+  let parsed;
+  try { parsed = JSON.parse(text); } catch { return []; }
+  const list = Array.isArray(parsed)
+    ? parsed
+    : (parsed && (parsed.data || parsed.models)) || [];
+  if (!Array.isArray(list)) return [];
+  const seen = new Map();
+  for (const entry of list) {
+    const id = String(typeof entry === 'string' ? entry : (entry && entry.id) || '').trim();
+    if (!id || seen.has(id)) continue;
+    const label = entry && typeof entry === 'object' && typeof entry.display_name === 'string'
+      ? entry.display_name.trim()
+      : '';
+    seen.set(id, { id, label: label || id });
+  }
+  return [...seen.values()].sort((a, b) => a.id.localeCompare(b.id)).slice(0, MAX_MODELS);
+}
+
+/**
+ * @param {object} opts
+ * @param {string} opts.baseUrl   The base URL the agent's CLI is pointed at.
+ * @param {string} opts.apiKey
+ * @param {string} [opts.protocol] 'anthropic', or OpenAI-compatible (default).
+ * @returns {Promise<{models: {id: string, label: string}[], error?: string}>}
+ */
+async function listEndpointModels({ baseUrl, apiKey, protocol = 'openai', fetchImpl = globalThis.fetch, timeoutMs = 15000 }) {
+  let url;
+  try {
+    url = new URL(/^[a-z][a-z0-9+.-]*:\/\//i.test(baseUrl) ? baseUrl : `http://${baseUrl}`);
+  } catch {
+    return { models: [], error: 'The configured base URL is not a valid URL.' };
+  }
+  if (!apiKey) return { models: [], error: 'No API key is configured for this agent.' };
+
+  const headers = { Accept: 'application/json' };
+  let path = url.pathname.replace(/\/+$/, '');
+  if (protocol === 'anthropic') {
+    // Official takes x-api-key; relays only ever honor a bearer token.
+    if (isOfficialAnthropic(url)) headers['x-api-key'] = apiKey;
+    else headers.Authorization = `Bearer ${apiKey}`;
+    headers['anthropic-version'] = '2023-06-01';
+    path = `${path.replace(/\/v1$/, '')}/v1/models`;
+    url.search = '?limit=100';
+  } else {
+    headers.Authorization = `Bearer ${apiKey}`;
+    // A bare host means the /v1 API; a path (…/v1, …/v1beta/openai) is used as given.
+    path = `${path || '/v1'}/models`;
+    url.search = '';
+  }
+  url.pathname = path;
+  url.username = '';
+  url.password = '';
+
+  let res;
+  let text;
+  try {
+    res = await fetchImpl(url.toString(), { headers, signal: AbortSignal.timeout(timeoutMs) });
+    text = await res.text();
+  } catch (e) {
+    const reason = e && e.name === 'TimeoutError' ? 'the endpoint did not answer in time' : (e && e.message) || String(e);
+    return { models: [], error: `Could not reach ${url.host}: ${reason}` };
+  }
+  if (res.status >= 400) {
+    return { models: [], error: `HTTP ${res.status}: ${briefError(text)}` };
+  }
+  const models = parseModels(text);
+  return models.length ? { models } : { models: [], error: 'The endpoint listed no models.' };
+}
+
+module.exports = { listEndpointModels, parseModels };

package/src/paths.js

@@ -1132,6 +1132,105 @@ function aiderBinDirs() {
 /** Executable suffixes to try for a bare binary name, per platform. */
 const BIN_EXTS = IS_WINDOWS ? ['.cmd', '.exe', '.bat', ''] : [''];
 
+/**
+ * A `#!...node` shebang line, as the Windows launcher matches it (win-exec.ts).
+ * `env -S`/flag forms are allowed; `#!/bin/sh -c node` is NOT a node script.
+ */
+const NODE_SHEBANG_RE =
+  /^#!\s*(?:(?:\S*[\\/])?env(?:\.exe)?\s+(?:-\S+\s+)*)?(?:\S*[\\/])?node(?:\.exe)?(?:\s|$)/i;
+
+/**
+ * True when a file is an extensionless Node script — npm's package bin shape
+ * (e.g. node_modules/cline/bin/cline). Windows cannot execute one: handed to
+ * cmd.exe it fails with "is not recognized as an internal or external command",
+ * so every caller that shells out to a resolved binary must prefix `node`.
+ */
+function isNodeShebangScript(filePath) {
+  if (!filePath) return false;
+  try {
+    const fd = fs.openSync(filePath, 'r');
+    try {
+      const buf = Buffer.alloc(64);
+      const n = fs.readSync(fd, buf, 0, buf.length, 0);
+      const firstLine = buf.subarray(0, n).toString('utf-8').split('\n', 1)[0];
+      return NODE_SHEBANG_RE.test(firstLine);
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return false;
+  }
+}
+
+/** Managed npm module roots, in the same priority order used by Installer. */
+function managedNpmModuleDirs(agentType) {
+  const dirs = [
+    path.join(getRuntimePrefix(agentType), 'node_modules'),
+    path.join(os.homedir(), '.openagents', 'nodejs', 'node_modules'),
+  ];
+  return [...new Set(dirs)];
+}
+
+/**
+ * Resolve a package's declared `bin` target from an OpenAgents-managed npm
+ * prefix. This covers packages such as Cline whose root package is installed
+ * successfully but npm does not create a node_modules/.bin shim for it.
+ */
+function resolveManagedNpmPackageBin(agentType, packageName, binaryName) {
+  if (!agentType || !packageName || !binaryName) return null;
+
+  for (const modules of managedNpmModuleDirs(agentType)) {
+    const pkgDir = path.join(modules, packageName);
+    const pkgJsonPath = path.join(pkgDir, 'package.json');
+    try {
+      if (!fs.existsSync(pkgJsonPath)) continue;
+      const bin = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8')).bin;
+      let rel = null;
+      if (typeof bin === 'string') rel = bin;
+      else if (bin && typeof bin === 'object') {
+        rel = bin[binaryName] || bin[packageName] || Object.values(bin)[0];
+      }
+      if (!rel) continue;
+      const abs = path.join(pkgDir, rel);
+      if (fs.existsSync(abs) && fs.statSync(abs).isFile()) return abs;
+    } catch {
+      /* malformed or unreadable package — keep looking */
+    }
+  }
+  return null;
+}
+
+/**
+ * Resolve the copy of an npm CLI installed in an OpenAgents-managed prefix.
+ * Package presence gates the lookup so an orphaned shim cannot shadow a
+ * working global install. The package's own bin is the final managed fallback.
+ */
+function resolveManagedNpmBinary(agentType, packageName, names) {
+  const list = (Array.isArray(names) ? names : [names]).filter(Boolean);
+  if (!agentType || !packageName || !list.length) return null;
+
+  for (const modules of managedNpmModuleDirs(agentType)) {
+    try {
+      if (!fs.existsSync(path.join(modules, packageName, 'package.json'))) continue;
+    } catch {
+      continue;
+    }
+    for (const name of list) {
+      for (const ext of BIN_EXTS) {
+        const candidate = path.join(modules, '.bin', `${name}${ext}`);
+        try {
+          if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
+        } catch {
+          /* unreadable shim — keep looking */
+        }
+      }
+    }
+    const own = resolveManagedNpmPackageBin(agentType, packageName, list[0]);
+    if (own) return own;
+  }
+  return null;
+}
+
 /**
  * Last-resort binary lookup: walk the directories we already know agent CLIs
  * land in and check the filesystem directly, instead of asking the shell.
@@ -1205,6 +1304,9 @@ module.exports = {
   getEnhancedEnv,
   whichBinary,
   whereBinary,
+  resolveManagedNpmBinary,
+  resolveManagedNpmPackageBin,
+  isNodeShebangScript,
   resolveBinaryInKnownDirs,
   clearBinaryLookupCache,
   primeBinaryLookup,

package/src/probe.js

@@ -58,6 +58,24 @@ const CODE = {
   CLI_ERROR: 'cli_error',
 };
 
+/**
+ * The install command for THIS device's platform.
+ *
+ * `entry.install_command` comes off the catalog API, which picks macOS → Linux
+ * → Windows with no idea who is asking — so a Windows user was told to fix a
+ * missing CLI by running a `curl … | bash` one-liner that cannot work there.
+ * The entry's own per-platform `install` block is the authority (same rule as
+ * Installer._getInstallCommand); the flat field stays as the fallback for
+ * catalog entries that carry nothing else.
+ */
+function installCommandFor(entry) {
+  const inst = (entry && entry.install) || {};
+  const plat = process.platform === 'darwin' ? 'macos'
+    : process.platform === 'win32' ? 'windows'
+      : 'linux';
+  return inst[plat] || inst.command || inst.npm || (entry && entry.install_command) || null;
+}
+
 /** Redact anything that looks like a secret before output leaves the device. */
 function scrub(text) {
   if (!text) return '';
@@ -129,7 +147,10 @@ function buildGuidance(code, entry, agentEnv, extra = {}) {
   switch (code) {
     case CODE.NOT_INSTALLED:
       lines.push(`${label} is not installed on this device. Install it from the launcher's Install page.`);
-      if (entry && entry.install_command) lines.push(`Or install manually: ${entry.install_command}`);
+      {
+        const cmd = installCommandFor(entry);
+        if (cmd) lines.push(`Or install manually: ${cmd}`);
+      }
       break;
     case CODE.INVALID_API_KEY:
     case CODE.MISSING_API_KEY:
@@ -388,4 +409,4 @@ async function probeAgentType(connector, type, opts = {}) {
   });
 }
 
-module.exports = { probeAgentType, classifyFailure, buildGuidance, authFlavor, scrub, CODE, DEFAULT_TIMEOUT_MS };
+module.exports = { probeAgentType, classifyFailure, buildGuidance, authFlavor, installCommandFor, scrub, CODE, DEFAULT_TIMEOUT_MS };