@openagents-org/agent-launcher 0.2.128 → 0.2.131

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagents-org/agent-launcher",
-  "version": "0.2.128",
+  "version": "0.2.131",
   "description": "OpenAgents Launcher — install, configure, and run AI coding agents from your terminal",
   "main": "src/index.js",
   "bin": {

package/registry.json

@@ -209,49 +209,46 @@
     "order": 4,
     "builtin": true,
     "install": {
-      "binary": "cursor",
-      "verify": "cursor --version 2>/dev/null | grep -qi cursor",
-      "verify_win": "cursor --version 2>nul | findstr /i cursor",
-      "requires": [
-        null
+      "binary": "cursor-agent",
+      "binary_aliases": [
+        "agent"
       ],
+      "verify": "cursor-agent --version 2>/dev/null | head -1",
+      "verify_win": "cursor-agent --version 2>nul",
+      "requires": [],
       "macos": "curl https://cursor.com/install -fsSL | bash",
       "linux": "curl https://cursor.com/install -fsSL | bash",
-      "windows": "echo 'Download Cursor from https://cursor.com/downloads'"
+      "windows": "\"%SystemRoot%\\System32\\WindowsPowerShell\\v1.0\\powershell.exe\" -NoProfile -ExecutionPolicy Bypass -Command \"Invoke-RestMethod -UseBasicParsing 'https://cursor.com/install?win32=true' | Invoke-Expression\""
     },
     "adapter": {
       "module": "openagents.adapters.cursor",
       "class": "CursorAdapter"
     },
     "launch": {
-      "args": [
-        null
-      ]
+      "args": []
     },
     "env_config": [
       {
-        "name": "OPENAI_API_KEY",
-        "description": "API key for LLM inference",
-        "required": true,
+        "name": "CURSOR_API_KEY",
+        "description": "Cursor API key for CLI authentication",
+        "required": false,
         "password": true
+      },
+      {
+        "name": "CURSOR_MODEL",
+        "description": "Model to use (e.g. claude-sonnet-4-6, gpt-4o)",
+        "required": false
       }
     ],
     "check_ready": {
-      "env_vars": [
-        "OPENAI_API_KEY"
-      ],
-      "saved_env_key": "OPENAI_API_KEY",
-      "not_ready_message": "No API key \u2014 press e to configure"
+      "binary": "agent",
+      "not_ready_message": "Cursor CLI not found \u2014 install with: curl https://cursor.com/install -fsSL | bash"
     },
     "resolve_env": {
       "rules": [
         {
           "from": "LLM_API_KEY",
-          "to": "OPENAI_API_KEY"
-        },
-        {
-          "from": "LLM_BASE_URL",
-          "to": "OPENAI_BASE_URL"
+          "to": "CURSOR_API_KEY"
         },
         {
           "from": "LLM_MODEL",

package/src/adapters/base.js

@@ -42,6 +42,7 @@ class BaseAdapter {
     this.workingDir = workingDir || undefined;
     this.client = new WorkspaceClient(this.endpoint);
     this._lastEventId = null;
+    this._lastToolResultId = null;
     this._running = false;
     this._sessionId = null;  // issued by server on /v1/join; used to prove liveness
     this._processedIds = new Set();
@@ -52,6 +53,11 @@ class BaseAdapter {
     // Per-channel task tracking for parallel execution
     this._channelBusy = new Set();
     this._channelQueues = {};
+    // Cached workspace.browser_enabled. Populated lazily on first read so we
+    // don't pay an HTTP roundtrip per message — adapters that toggle the
+    // workspace flag must reconnect/restart to pick up the change (matches
+    // the Python adapter behavior in workspace_prompt.py).
+    this._browserEnabledCache = null;
     // Wall-clock timestamp of adapter init, used by the `status` control
     // action to report uptime back to the channel. Reset on reinstantiation
     // (e.g. after a `restart` IPC bounce) so uptime tracks "time since last
@@ -209,6 +215,8 @@ class BaseAdapter {
   async _onControlAction(action, payload) {
     if (action === 'status') {
       await this._postStatusReport(payload);
+    } else if (action === 'routines') {
+      await this._postRoutinesReport(payload);
     }
   }
 
@@ -261,6 +269,74 @@ class BaseAdapter {
     }
   }
 
+  /**
+   * Post a markdown table of the agent's active routines back to the
+   * requesting channel. Used by the `/routines` slash command. Each agent
+   * reports only routines it owns (created_by === openagents:<agentName>)
+   * so the user sees a clear "my routines" view per agent, mirroring how
+   * /status reports per-agent uptime.
+   */
+  async _postRoutinesReport(payload) {
+    const channel = (payload && typeof payload === 'object') ? payload.channel : null;
+    if (!channel) return;
+
+    let routines = [];
+    try {
+      const data = await this.client.listRoutines(this.workspaceId, channel, this.token);
+      // Accept both the canonical `openagents:<name>` source and the bare
+      // `<name>` form. Agents that follow the workspace prompt verbatim
+      // produce the prefixed form, but some agents send the bare name when
+      // they construct the POST body themselves.
+      const prefixed = `openagents:${this.agentName}`;
+      routines = ((data && data.routines) || []).filter(
+        (r) => r.created_by === prefixed || r.created_by === this.agentName,
+      );
+    } catch (e) {
+      this._log(`Routines: failed to list: ${e && e.message ? e.message : e}`);
+      try {
+        await this.client.sendMessage(
+          this.workspaceId, channel, this.token,
+          `**Routines for \`${this.agentName}\`**\n\n_Failed to fetch routines._`,
+          { senderType: 'agent', senderName: this.agentName, messageType: 'chat', sessionId: this._sessionId },
+        );
+      } catch {}
+      return;
+    }
+
+    let content;
+    if (!routines.length) {
+      content = `**Routines for \`${this.agentName}\`**\n\n_No active routines._`;
+    } else {
+      const rows = routines.map((r) => {
+        const schedule = (r.schedule_interval_minutes != null)
+          ? `every ${r.schedule_interval_minutes} min`
+          : `${String(r.schedule_hour ?? 0).padStart(2, '0')}:${String(r.schedule_minute ?? 0).padStart(2, '0')} UTC` +
+            (r.schedule_days ? ` (days [${r.schedule_days.join(',')}])` : ' daily');
+        const next = r.next_fires_at || '—';
+        const name = String(r.name || '').replace(/\|/g, '\\|');
+        const id = String(r.id || '').slice(0, 8);
+        return `| \`${id}\` | ${name} | ${schedule} | ${next} |`;
+      });
+      content =
+        `**Routines for \`${this.agentName}\`** (${routines.length})\n\n` +
+        '| ID | Name | Schedule | Next fires |\n' +
+        '|---|---|---|---|\n' +
+        rows.join('\n');
+    }
+
+    try {
+      await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
+        senderType: 'agent',
+        senderName: this.agentName,
+        messageType: 'chat',
+        metadata: { agent_mode: this._mode },
+        sessionId: this._sessionId,
+      });
+    } catch (e) {
+      this._log(`Routines: failed to post: ${e && e.message ? e.message : e}`);
+    }
+  }
+
   _hasActiveWork() {
     return this._channelBusy.size > 0;
   }
@@ -305,7 +381,7 @@ class BaseAdapter {
 
     while (this._running) {
       pollCount++;
-      let messages, rawCursor;
+      let messages, rawCursor, composingActive = false;
       try {
         const result = await this.client.pollPending(
           this.workspaceId, this.agentName, this.token,
@@ -313,8 +389,9 @@ class BaseAdapter {
         );
         messages = result.messages;
         rawCursor = result.cursor;
+        composingActive = !!result.composing;
         if (pollCount <= 3 || pollCount % 20 === 0) {
-          this._log(`Poll #${pollCount}: ${messages.length} messages, cursor=${rawCursor || 'none'}`);
+          this._log(`Poll #${pollCount}: ${messages.length} messages, cursor=${rawCursor || 'none'}${composingActive ? ' composing' : ''}`);
         }
       } catch (e) {
         this._log(`Poll #${pollCount} failed: ${e.message} \nStack: ${e.stack}`);
@@ -358,11 +435,51 @@ class BaseAdapter {
         idleCount++;
       }
 
-      // Adaptive polling: 2s active, up to 15s idle.
-      // Each connected agent runs this loop, so faster rates multiply across
-      // every workspace member — keep this conservative and tune separately
-      // with a load-impact analysis on workspace-endpoint.
-      const delay = incoming.length > 0 ? 2000 : Math.min(2000 + idleCount * 1000, 15000);
+      // Sidecar poll: A2UI tool_result events. These are the user's response
+      // to a UI spec this agent (or any agent in the network) emitted. We
+      // surface each one as a synthetic user message so the LLM sees it as
+      // the next turn and can react. Failures here don't break the main
+      // message poll.
+      try {
+        const toolResult = await this.client.pollToolResults(
+          this.workspaceId, this.token,
+          { after: this._lastToolResultId }
+        );
+        if (toolResult.cursor) this._lastToolResultId = toolResult.cursor;
+        for (const event of toolResult.events || []) {
+          const msgId = event.id;
+          if (msgId && this._processedIds.has(msgId)) continue;
+          if (msgId) this._processedIds.add(msgId);
+          const synth = synthesizeToolResultMessage(event);
+          if (synth) await this._dispatchMessage(synth);
+        }
+      } catch (e) {
+        // Non-fatal — log once per poll if it fails
+        if (pollCount <= 3 || pollCount % 20 === 0) {
+          this._log(`tool_result poll #${pollCount} failed: ${e.message}`);
+        }
+      }
+
+      // Adaptive polling with warm plateau:
+      //   Active (messages incoming):  2s
+      //   Warm (≤5 min since last msg): 5s
+      //   Cooldown (5-7 min):          5s → 15s (ramp 1s per idle poll)
+      //   Cold (>7 min):              15s
+      // The warm plateau keeps the agent responsive during typical user
+      // think-time between messages without hammering the backend.
+      const WARM_INTERVAL = 5000;
+      const WARM_POLLS = 60;  // 60 × 5s = 5 minutes warm plateau
+      let delay;
+      if (incoming.length > 0) {
+        delay = 2000;
+      } else if (composingActive) {
+        delay = 2000;
+        idleCount = Math.min(idleCount, WARM_POLLS);
+      } else if (idleCount <= WARM_POLLS) {
+        delay = WARM_INTERVAL;
+      } else {
+        delay = Math.min(WARM_INTERVAL + (idleCount - WARM_POLLS) * 1000, 15000);
+      }
       await this._sleep(delay);
     }
   }
@@ -421,6 +538,9 @@ class BaseAdapter {
       const queue = this._channelQueues[channel];
       if (!queue || queue.length === 0) break;
       const nextMsg = queue.shift();
+      if (nextMsg._queueId) {
+        try { await this.sendStatus(channel, 'processing queued message', { queue_id: nextMsg._queueId, queue_status: 'processed' }); } catch {}
+      }
       try {
         await this._handleMessage(nextMsg);
       } catch (e) {
@@ -473,8 +593,15 @@ class BaseAdapter {
   }
 
   async sendThinking(channel, content) {
+    // Strip ```a2ui blocks if they leak into Claude's intermediate thinking
+    // trace — the real spec gets emitted via sendResponse with proper
+    // payload.spec extraction, so showing the raw block here is just noise
+    // (and a duplicate). If stripping leaves the thinking message empty,
+    // skip it entirely.
+    const { cleanContent } = extractA2UISpec(content);
+    if (!cleanContent || !cleanContent.trim()) return;
     try {
-      await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
+      await this.client.sendMessage(this.workspaceId, channel, this.token, cleanContent, {
         senderType: 'agent',
         senderName: this.agentName,
         messageType: 'thinking',
@@ -487,11 +614,14 @@ class BaseAdapter {
   }
 
   async sendResponse(channel, content) {
+    const { cleanContent, spec, specToolCallId } = extractA2UISpec(content);
     try {
-      await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
+      await this.client.sendMessage(this.workspaceId, channel, this.token, cleanContent, {
         senderType: 'agent',
         senderName: this.agentName,
         sessionId: this._sessionId,
+        spec,
+        specToolCallId,
       });
     } catch (e) {
       if (e instanceof SessionRevokedError) {
@@ -597,6 +727,95 @@ class BaseAdapter {
   _sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
+
+  /**
+   * Return whether the workspace has the Browser Fabric viewer toggle on.
+   * Cached for the lifetime of the adapter — restart to pick up a flip.
+   * Falls back to false on error so the prompt builders don't accidentally
+   * inject the strong directive against an older backend that can't route
+   * to Browser Fabric.
+   */
+  async getBrowserEnabled() {
+    if (this._browserEnabledCache === null) {
+      try {
+        const meta = await this.client.getWorkspaceMetadata(this.workspaceId, this.token);
+        this._browserEnabledCache = !!(meta && meta.browserEnabled);
+      } catch (e) {
+        this._browserEnabledCache = false;
+      }
+    }
+    return this._browserEnabledCache;
+  }
+}
+
+// ------------------------------------------------------------------
+// A2UI helpers
+// ------------------------------------------------------------------
+
+/**
+ * Pull the first ```a2ui ... ``` fenced block out of LLM-produced content.
+ * Returns the content with the block stripped, the parsed spec, and a
+ * tool-call id derived from `spec.tool_call_id` (if present) or a new one.
+ * If no block is present or parsing fails, returns the content unchanged
+ * with null spec — the message still goes out as plain markdown.
+ */
+/**
+ * Convert a workspace.tool_result event into a synthetic user-message
+ * shape that the agent's _handleMessage can dispatch. The LLM sees this
+ * as the next user turn — the content is a short, machine-readable line
+ * the LLM can parse without ambiguity. The original spec it emitted is
+ * already in the LLM's conversation history; the tool_call_id lets the
+ * LLM correlate this back.
+ */
+function synthesizeToolResultMessage(event) {
+  if (!event || !event.payload) return null;
+  const p = event.payload;
+  const actionId = p.action_id || '';
+  const toolCallId = p.tool_call_id || '';
+  let valueStr = '';
+  if (p.value !== undefined && p.value !== null) {
+    try { valueStr = JSON.stringify(p.value); } catch (_) { valueStr = String(p.value); }
+  }
+  const lines = [
+    '[ui_action]',
+    `action=${actionId}`,
+    toolCallId ? `tool_call_id=${toolCallId}` : null,
+    valueStr ? `value=${valueStr}` : null,
+  ].filter(Boolean);
+  const content = lines.join(' ');
+  const target = event.target || '';
+  return {
+    messageId: event.id || '',
+    sessionId: target.startsWith('channel/') ? target.replace('channel/', '') : target,
+    senderType: 'human',
+    senderName: 'user',
+    content,
+    mentions: [],
+    messageType: 'chat',
+    metadata: event.metadata || {},
+  };
+}
+
+function extractA2UISpec(content) {
+  if (!content || typeof content !== 'string') {
+    return { cleanContent: content, spec: null, specToolCallId: null };
+  }
+  const match = content.match(/```a2ui\s*\n([\s\S]*?)\n```/);
+  if (!match) return { cleanContent: content, spec: null, specToolCallId: null };
+
+  let spec;
+  try {
+    spec = JSON.parse(match[1]);
+  } catch (_) {
+    return { cleanContent: content, spec: null, specToolCallId: null };
+  }
+
+  const specToolCallId = (spec && spec.tool_call_id) || `tc_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  if (spec && spec.tool_call_id) delete spec.tool_call_id;
+
+  const cleanContent = content.replace(match[0], '').trim();
+  return { cleanContent, spec, specToolCallId };
 }
 
 module.exports = BaseAdapter;
+module.exports.extractA2UISpec = extractA2UISpec;

package/src/adapters/claude.js

@@ -358,7 +358,7 @@ class ClaudeAdapter extends BaseAdapter {
     return null;
   }
 
-  _buildClaudeCmd(prompt, channelName, { skipResume = false } = {}) {
+  _buildClaudeCmd(prompt, channelName, { skipResume = false, browserEnabled = false } = {}) {
     const claudeBin = this._findClaudeBinary();
     if (!claudeBin) {
       throw new Error('claude CLI not found. Install with: curl -fsSL https://claude.ai/install.sh | bash');
@@ -369,6 +369,7 @@ class ClaudeAdapter extends BaseAdapter {
       workspaceId: this.workspaceId,
       channelName,
       mode: this._mode,
+      browserEnabled,
     });
 
     // In skills mode, replace MCP tool references with curl-based instructions
@@ -432,6 +433,7 @@ class ClaudeAdapter extends BaseAdapter {
       agentName: this.agentName,
       channelName,
       disabledModules: this.disabledModules,
+      browserEnabled: this._browserEnabledCache === true,
     });
     fs.writeFileSync(skillFile, skillContent, 'utf-8');
     this._log(`Wrote workspace skill to ${skillFile}`);
@@ -569,7 +571,7 @@ class ClaudeAdapter extends BaseAdapter {
     let content = (msg.content || '').trim();
     const attachments = msg.attachments || [];
 
-    const attText = formatAttachmentsForPrompt(attachments);
+    const attText = formatAttachmentsForPrompt(attachments, this.toolMode);
     if (attText) {
       content = content ? content + attText : attText.trim();
     }
@@ -648,7 +650,11 @@ class ClaudeAdapter extends BaseAdapter {
       }
 
       try {
-        const built = this._buildClaudeCmd(effectiveContent, msgChannel, { skipResume: attempt > 0 });
+        const browserEnabled = await this.getBrowserEnabled();
+        const built = this._buildClaudeCmd(effectiveContent, msgChannel, {
+          skipResume: attempt > 0,
+          browserEnabled,
+        });
         cmd = built.cmd;
         mcpConfigFile = built.mcpConfigFile;
       } catch (e) {
@@ -853,6 +859,27 @@ class ClaudeAdapter extends BaseAdapter {
             }
           }
 
+          // In plan mode, read the plan file and include it in the response
+          if (this._mode === 'plan') {
+            try {
+              const planDir = path.join(this.workingDir || process.cwd(), '.claude', 'plans');
+              if (fs.existsSync(planDir)) {
+                const planFiles = fs.readdirSync(planDir)
+                  .filter((f) => f.endsWith('.md'))
+                  .map((f) => ({ name: f, mtime: fs.statSync(path.join(planDir, f)).mtimeMs }))
+                  .sort((a, b) => b.mtime - a.mtime);
+                if (planFiles.length > 0) {
+                  const planContent = fs.readFileSync(path.join(planDir, planFiles[0].name), 'utf-8').trim();
+                  if (planContent) {
+                    lastResponseText.push('\n\n---\n\n**Plan:**\n\n' + planContent);
+                  }
+                }
+              }
+            } catch (e) {
+              this._log(`Failed to read plan file: ${e.message}`);
+            }
+          }
+
           if (lastResponseText.length > 0) {
             const fullResponse = lastResponseText.join('\n').trim();
             // "Prompt is too long" means the resumed session's context