@openagents-org/agent-launcher 0.2.151 → 0.2.153

package/src/mcp-server.js

@@ -100,9 +100,66 @@ function buildToolDefs(disabledModules) {
     );
   }
 
+  // -- Search module --
+  if (!disabledModules.has('search')) {
+    tools.push(
+      {
+        name: 'workspace_image_search',
+        description:
+          'Search the web for images. Returns image URLs you can show in chat directly by embedding ' +
+          'markdown — ![title](image_url) — in your reply, or persist with workspace_image_save.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: { type: 'string', description: 'Image search query' },
+            count: { type: 'number', description: 'Number of results (default 10, max 20)' },
+          },
+          required: ['query'],
+        },
+      },
+      {
+        name: 'workspace_image_save',
+        description:
+          'Download an image (or any file) URL into workspace storage. By default it is also posted ' +
+          'into the current channel as an inline image attachment (set post_to_channel=false to only save).',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            url: { type: 'string', description: 'Direct image/file URL (e.g. image_url from workspace_image_search)' },
+            filename: { type: 'string', description: 'Filename to store as (derived from URL if omitted)' },
+            caption: { type: 'string', description: 'Message text to accompany the posted image' },
+            post_to_channel: { type: 'boolean', description: 'Post into the chat as an attachment (default true)' },
+          },
+          required: ['url'],
+        },
+      },
+    );
+  }
+
   // -- Browser module --
   if (!disabledModules.has('browser')) {
     tools.push(
+      {
+        name: 'workspace_fetch_url',
+        description:
+          'Read a web page as text WITHOUT opening a shared browser tab. Preferred way to read any URL: ' +
+          'tries a fast static fetch first, and automatically renders JavaScript-heavy pages (Notion, SPAs) ' +
+          'in a temporary browser session. Only open a shared browser tab (workspace_browser_open) when you ' +
+          'need to interact with the page (click/type/login) or the result says AUTH_REQUIRED.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            url: { type: 'string', description: 'URL to fetch (http/https)' },
+            mode: {
+              type: 'string',
+              enum: ['auto', 'static', 'render'],
+              description: 'auto (default): static first, browser render if needed. static: never use a browser. render: force browser rendering.',
+            },
+            max_chars: { type: 'number', description: 'Max characters of content to return (default 20000)' },
+          },
+          required: ['url'],
+        },
+      },
       {
         name: 'workspace_browser_open',
         description:
@@ -629,6 +686,61 @@ class McpServer {
 
       // ── Browser ──
 
+      case 'workspace_fetch_url': {
+        try {
+          const result = await this.ws.fetchUrl(this.workspaceId, this.token, args.url, {
+            mode: args.mode || 'auto',
+            maxChars: args.max_chars,
+            source: `openagents:${this.agentName}`,
+          });
+          const header = [
+            `URL: ${result.url}`,
+            result.title ? `Title: ${result.title}` : null,
+            `Source: ${result.content_source}${result.truncated ? ' (truncated)' : ''}`,
+          ].filter(Boolean).join('\n');
+          return text(`${header}\n\n${result.content || '(empty page)'}`);
+        } catch (e) {
+          const detail = e.data || {};
+          const parts = [`Fetch failed: ${e.message}`];
+          if (detail.error_code) parts.push(`Code: ${detail.error_code}`);
+          if (detail.hint) parts.push(`Hint: ${detail.hint}`);
+          return text(parts.join('\n'));
+        }
+      }
+
+      case 'workspace_image_search': {
+        const data = await this.ws.searchImages(this.workspaceId, this.token, args.query, {
+          count: args.count || 10,
+        });
+        const results = (data && data.results) || [];
+        if (!results.length) return text(`No image results for "${args.query}".`);
+        const lines = results.map((r, i) => {
+          const dims = r.width && r.height ? ` (${r.width}x${r.height})` : '';
+          return `${i + 1}. ${r.title || 'untitled'}${dims}\n` +
+            `   image_url: ${r.image_url}\n` +
+            `   source: ${r.page_url || r.source || 'unknown'}`;
+        });
+        return text(
+          `Found ${results.length} images for "${args.query}":\n\n${lines.join('\n')}\n\n` +
+          'To show one in chat, embed it in your reply as markdown: ![title](image_url). ' +
+          'To keep a copy in the workspace (and post it as an attachment), call workspace_image_save with the image_url.'
+        );
+      }
+
+      case 'workspace_image_save': {
+        const result = await this.ws.uploadFileFromUrl(this.workspaceId, this.token, args.url, {
+          filename: args.filename,
+          channelName: this.channelName,
+          source: `openagents:${this.agentName}`,
+          postToChannel: args.post_to_channel !== false,
+          caption: args.caption,
+        });
+        const posted = result.posted_to_channel
+          ? ' and posted to the channel'
+          : '';
+        return text(`Saved ${result.filename} (${result.content_type}, ${result.size} bytes, id: ${result.id})${posted}.`);
+      }
+
       case 'workspace_browser_open': {
         const opts = {
           url: args.url || 'about:blank',

package/src/paths.js

@@ -517,12 +517,69 @@ function aiderBinDirs() {
   return dirs;
 }
 
+/** Executable suffixes to try for a bare binary name, per platform. */
+const BIN_EXTS = IS_WINDOWS ? ['.cmd', '.exe', '.bat', ''] : [''];
+
+/**
+ * Last-resort binary lookup: walk the directories we already know agent CLIs
+ * land in and check the filesystem directly, instead of asking the shell.
+ *
+ * `where`/`which` is not enough on Windows. The Cursor, Amp and Hermes
+ * installers edit the *registry* PATH, which an already-running process never
+ * inherits — so a perfectly good install is invisible to a PATH lookup until
+ * the machine (or at least the app) is restarted. Every adapter grew its own
+ * tiered search to cope; the launcher had none, so it alone reported "can't
+ * find it" and then opened a terminal running a bare command that could only
+ * fail with "'cursor-agent' is not recognized".
+ *
+ * Deliberately reuses getExtraBinDirs() rather than a second hardcoded list:
+ * that list already IS the curated set, and a copy of it is exactly how the
+ * launcher and the adapters drifted apart in the first place.
+ *
+ * Runs only after a PATH lookup has already missed, so it can add resolutions
+ * but never change one that already works.
+ *
+ * @param {string|string[]} names  binary name(s), e.g. ['cursor-agent','agent']
+ * @param {string} [agentType]     adds that agent's isolated runtime bin dir
+ * @returns {string|null} absolute path, or null
+ */
+function resolveBinaryInKnownDirs(names, agentType) {
+  const list = (Array.isArray(names) ? names : [names]).filter(Boolean);
+  if (!list.length) return null;
+
+  const dirs = [];
+  const push = (d) => { if (d && !dirs.includes(d)) dirs.push(d); };
+
+  // The agent's own isolated runtime first — it is the copy this launcher
+  // installed, and should win over anything the user happens to have globally.
+  if (agentType) push(path.join(getRuntimePrefix(agentType), 'node_modules', '.bin'));
+  push(path.join(HOME, '.openagents', 'nodejs', 'node_modules', '.bin'));
+  try { push(path.dirname(process.execPath)); } catch {}
+  for (const d of getExtraBinDirs()) push(d);
+
+  for (const dir of dirs) {
+    for (const name of list) {
+      for (const ext of BIN_EXTS) {
+        const candidate = path.join(dir, `${name}${ext}`);
+        try {
+          if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
+        } catch {
+          /* unreadable path — keep looking */
+        }
+      }
+    }
+  }
+  return null;
+}
+
+
 module.exports = {
   getExtraBinDirs,
   getEnhancedPATH,
   getEnhancedEnv,
   whichBinary,
   whereBinary,
+  resolveBinaryInKnownDirs,
   clearBinaryLookupCache,
   getRuntimePrefix,
   getCorePrefix,

package/src/workspace-client.js

@@ -192,26 +192,29 @@ class WorkspaceClient {
   }
 
   /**
-   * Fetch the most recent N messages in a channel, returned oldest-to-newest.
-   * Used by adapters to rebuild context for a fresh Claude Code session
-   * when --resume of the previous session fails (the channel's chat history
-   * is the only thing that survives a session-storage rotation).
+   * Fetch N messages in a channel, returned oldest-to-newest. `sort` picks
+   * which end of the channel the window comes from: 'desc' (default) takes
+   * the most recent N, 'asc' takes the channel's opening N. Used by adapters
+   * to rebuild context for a fresh Claude Code session when --resume of the
+   * previous session fails (the channel's chat history is the only thing
+   * that survives a session-storage rotation).
    */
-  async getRecentMessages(workspaceId, channelName, token, limit = 30) {
+  async getRecentMessages(workspaceId, channelName, token, limit = 30, { sort = 'desc' } = {}) {
     try {
       const params = new URLSearchParams({
         network: workspaceId,
         channel: channelName,
         type: 'workspace.message',
-        sort: 'desc',
+        sort,
         limit: String(limit),
       });
       const data = await this._get(`/v1/events?${params}`, this._wsHeaders(token));
       const result = data.data || data;
       const events = (result && result.events) || [];
-      // Server returned newest-first; reverse so the caller can present them
-      // in chronological order without further fiddling.
-      return events.slice().reverse().map((e) => this._eventToMessage(e));
+      // A desc window arrives newest-first; reverse so the caller always gets
+      // chronological order. An asc window is already chronological.
+      const ordered = sort === 'asc' ? events.slice() : events.slice().reverse();
+      return ordered.map((e) => this._eventToMessage(e));
     } catch {
       return [];
     }
@@ -471,6 +474,31 @@ class WorkspaceClient {
     return data.data || data;
   }
 
+  /**
+   * Search the web for images via POST /v1/search/images.
+   */
+  async searchImages(workspaceId, token, query, { count = 10 } = {}) {
+    const body = { query, network: workspaceId, count };
+    const data = await this._post('/v1/search/images', body, this._wsHeaders(token), 30000);
+    return data.data || data;
+  }
+
+  /**
+   * Download a URL into workspace storage via POST /v1/files/from_url.
+   * With postToChannel, the file is also posted into the chat as an
+   * inline attachment.
+   */
+  async uploadFileFromUrl(workspaceId, token, url, {
+    filename, channelName, source = 'human:user', postToChannel = false, caption,
+  } = {}) {
+    const body = { url, network: workspaceId, source, post_to_channel: postToChannel };
+    if (filename) body.filename = filename;
+    if (channelName) body.channel_name = channelName;
+    if (caption) body.caption = caption;
+    const data = await this._post('/v1/files/from_url', body, this._wsHeaders(token), 90000);
+    return data.data || data;
+  }
+
   /**
    * List files via GET /v1/files.
    */
@@ -583,6 +611,19 @@ class WorkspaceClient {
     return data.data || data;
   }
 
+  /**
+   * Server-side fetch chain via POST /v1/fetch — reads a page WITHOUT
+   * holding a shared browser tab. Static HTTP first; JS-heavy pages are
+   * rendered in an ephemeral browser session that is closed immediately.
+   */
+  async fetchUrl(workspaceId, token, url, { mode = 'auto', maxChars, source } = {}) {
+    const body = { url, network: workspaceId, mode };
+    if (maxChars) body.max_chars = maxChars;
+    if (source) body.source = source;
+    const data = await this._post('/v1/fetch', body, this._wsHeaders(token), 90000);
+    return data.data || data;
+  }
+
   /**
    * List persistent browser contexts via GET /v1/browser/contexts.
    */
@@ -699,18 +740,18 @@ class WorkspaceClient {
 
   // ── Knowledge Base ──
 
-  async listKnowledge(workspaceId, token, { limit = 100 } = {}) {
+  async listKnowledge(workspaceId, token, { limit = 100, timeout } = {}) {
     const params = new URLSearchParams({
       network: workspaceId,
       limit: String(limit),
     });
-    const data = await this._get(`/v1/knowledge?${params}`, this._wsHeaders(token));
+    const data = await this._get(`/v1/knowledge?${params}`, this._wsHeaders(token), timeout);
     return data.data || data;
   }
 
-  async getKnowledge(workspaceId, token, entryId) {
+  async getKnowledge(workspaceId, token, entryId, { timeout } = {}) {
     const params = new URLSearchParams({ network: workspaceId });
-    const data = await this._get(`/v1/knowledge/${entryId}?${params}`, this._wsHeaders(token));
+    const data = await this._get(`/v1/knowledge/${entryId}?${params}`, this._wsHeaders(token), timeout);
     return data.data || data;
   }
 
@@ -878,7 +919,11 @@ class WorkspaceClient {
               if (typeof msg === 'string' && msg.toLowerCase().includes('session_revoked')) {
                 reject(new SessionRevokedError(msg));
               } else {
-                reject(new Error(msg));
+                const err = new Error(msg);
+                // Preserve structured error details (error_code, hint,
+                // quota occupancy, ...) so tool handlers can surface them.
+                if (parsed.data && typeof parsed.data === 'object') err.data = parsed.data;
+                reject(err);
               }
             } else {
               resolve(parsed);