@openagents-org/agent-launcher 0.2.130 → 0.2.132

package/package.json

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

package/registry.json

@@ -209,14 +209,16 @@
     "order": 4,
     "builtin": true,
     "install": {
-      "binary": "agent",
-      "verify": "agent --version 2>/dev/null | head -1",
-      "verify_win": "agent --version 2>nul",
+      "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": "irm 'https://cursor.com/install?win32=true' | iex",
-      "npm": "npm install -g @cursor/cli"
+      "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",

package/src/adapters/base.js

@@ -53,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
@@ -85,6 +90,19 @@ class BaseAdapter {
       this._log(`Warning: join failed: ${e.message} \nStack: ${e.stack}`);
     }
 
+    // Sync workspace-managed skills into disabledModules
+    try {
+      const agents = await this.client.getAgents(this.workspaceId, this.token);
+      const self = agents.find((a) => a.agentName === this.agentName);
+      if (self && self.enabledSkills) {
+        const { skillsToDisabledModules } = require('../skill-catalog');
+        this.disabledModules = skillsToDisabledModules(self.enabledSkills);
+        this._log(`Synced skills from workspace: disabled=[${[...this.disabledModules].join(',')}]`);
+      }
+    } catch (e) {
+      this._log(`Warning: skill sync failed (non-fatal): ${e.message}`);
+    }
+
     // Fast-path operations (control-event cursor + heartbeat + control poll)
     // run BEFORE the message-cursor advance. Even though _skipExistingEvents
     // is fast on a healthy backend, we don't want slash commands gated on
@@ -210,6 +228,8 @@ class BaseAdapter {
   async _onControlAction(action, payload) {
     if (action === 'status') {
       await this._postStatusReport(payload);
+    } else if (action === 'routines') {
+      await this._postRoutinesReport(payload);
     }
   }
 
@@ -262,6 +282,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;
   }
@@ -306,7 +394,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,
@@ -314,8 +402,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}`);
@@ -384,11 +473,26 @@ class BaseAdapter {
         }
       }
 
-      // 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);
+      // 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);
     }
   }
@@ -636,6 +740,25 @@ 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;
+  }
 }
 
 // ------------------------------------------------------------------