@openagents-org/agent-launcher 0.2.130 → 0.2.132

package/src/mcp-server.js

@@ -235,106 +235,202 @@ function buildToolDefs(disabledModules) {
     );
   }
 
-  // -- Todos & Timers (always enabled) --
-  tools.push(
-    {
-      name: 'workspace_put_todos',
-      description: 'Update your to-do list. Replaces the entire list each time (send full list with current statuses). Channel is auto-resolved.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          todos: {
-            type: 'array',
-            items: {
-              type: 'object',
-              properties: {
-                content: { type: 'string', description: 'Task description' },
-                status: { type: 'string', enum: ['pending', 'in_progress', 'completed'], description: 'Task status' },
-                assignee: { type: 'string', description: 'Agent name to assign to (defaults to self)' },
+  // -- Todos --
+  if (!disabledModules.has('todos')) {
+    tools.push(
+      {
+        name: 'workspace_put_todos',
+        description: 'Update your to-do list. Replaces the entire list each time (send full list with current statuses). Channel is auto-resolved.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            todos: {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: {
+                  content: { type: 'string', description: 'Task description' },
+                  status: { type: 'string', enum: ['pending', 'in_progress', 'completed'], description: 'Task status' },
+                  assignee: { type: 'string', description: 'Agent name to assign to (defaults to self)' },
+                },
+                required: ['content', 'status'],
               },
-              required: ['content', 'status'],
+              description: 'Full to-do list with current statuses',
             },
-            description: 'Full to-do list with current statuses',
           },
+          required: ['todos'],
         },
-        required: ['todos'],
       },
-    },
-    {
-      name: 'workspace_get_todos',
-      description: 'Get to-do items for the current channel. Use all=true to see all agents\' todos.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          agent: { type: 'string', description: 'Filter by agent name' },
-          all: { type: 'boolean', description: 'Get all agents\' todos (default: own only)' },
+      {
+        name: 'workspace_get_todos',
+        description: 'Get to-do items for the current channel. Use all=true to see all agents\' todos.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            agent: { type: 'string', description: 'Filter by agent name' },
+            all: { type: 'boolean', description: 'Get all agents\' todos (default: own only)' },
+          },
         },
       },
-    },
-    {
-      name: 'workspace_create_timer',
-      description: 'Set a timer that posts a message to the channel after the specified delay.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          delay: { type: 'integer', description: 'Seconds until the timer fires (1-86400)' },
-          message: { type: 'string', description: 'Message to post when the timer fires' },
+    );
+  }
+
+  // -- Timers --
+  if (!disabledModules.has('timers')) {
+    tools.push(
+      {
+        name: 'workspace_create_timer',
+        description: 'Set a timer that posts a message to the channel after the specified delay.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            delay: { type: 'integer', description: 'Seconds until the timer fires (1-86400)' },
+            message: { type: 'string', description: 'Message to post when the timer fires' },
+          },
+          required: ['delay', 'message'],
         },
-        required: ['delay', 'message'],
       },
-    },
-    {
-      name: 'workspace_list_timers',
-      description: 'List active timers in the current channel.',
-      inputSchema: { type: 'object', properties: {} },
-    },
-    {
-      name: 'workspace_cancel_timer',
-      description: 'Cancel an active timer by its ID.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          timer_id: { type: 'string', description: 'Timer ID to cancel' },
+      {
+        name: 'workspace_list_timers',
+        description: 'List active timers in the current channel.',
+        inputSchema: { type: 'object', properties: {} },
+      },
+      {
+        name: 'workspace_cancel_timer',
+        description: 'Cancel an active timer by its ID.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            timer_id: { type: 'string', description: 'Timer ID to cancel' },
+          },
+          required: ['timer_id'],
         },
-        required: ['timer_id'],
       },
-    },
-    {
-      name: 'workspace_create_routine',
-      description: 'Create a recurring scheduled routine that posts a message on a repeating schedule.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          name: { type: 'string', description: 'Human-readable label for the routine (e.g. "Daily PR Review")' },
-          message: { type: 'string', description: 'Message to post each time the routine fires' },
-          hour: { type: 'integer', description: 'Hour in UTC (0-23)' },
-          minute: { type: 'integer', description: 'Minute (0-59)' },
-          days: {
-            type: 'array',
-            items: { type: 'integer' },
-            description: 'Days of week to fire (0=Mon, 6=Sun). Omit for every day.',
+    );
+  }
+
+  // -- Routines --
+  if (!disabledModules.has('routines')) {
+    tools.push(
+      {
+        name: 'workspace_create_routine',
+        description: 'Create a recurring scheduled routine. Each routine gets its own dedicated thread with full context. Two schedule modes: daily (hour+minute, optional days) or interval (every N minutes).',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Human-readable label for the routine (e.g. "Daily PR Review")' },
+            message: { type: 'string', description: 'Short trigger message posted each time the routine fires' },
+            context: { type: 'string', description: 'Comprehensive context for the routine: what it should do, background info, goals, relevant details from the current conversation. This is posted at the start of the routine\'s dedicated thread so you have full background every time it fires. Be thorough — this is your only memory of why this routine exists.' },
+            hour: { type: 'integer', description: 'Daily mode: hour in UTC (0-23). Omit if using interval_minutes.' },
+            minute: { type: 'integer', description: 'Daily mode: minute (0-59). Omit if using interval_minutes.' },
+            days: {
+              type: 'array',
+              items: { type: 'integer' },
+              description: 'Daily mode: days of week to fire (0=Mon, 6=Sun). Omit for every day. Not allowed in interval mode.',
+            },
+            interval_minutes: {
+              type: 'integer',
+              description: 'Interval mode: fire every N minutes (1-1440). Mutually exclusive with hour/minute.',
+            },
           },
+          required: ['name', 'message', 'context'],
         },
-        required: ['name', 'message', 'hour', 'minute'],
       },
-    },
-    {
-      name: 'workspace_list_routines',
-      description: 'List active routines in the current channel.',
-      inputSchema: { type: 'object', properties: {} },
-    },
-    {
-      name: 'workspace_cancel_routine',
-      description: 'Cancel a recurring routine by its ID.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          routine_id: { type: 'string', description: 'Routine ID to cancel' },
+      {
+        name: 'workspace_list_routines',
+        description: 'List active routines in the current channel.',
+        inputSchema: { type: 'object', properties: {} },
+      },
+      {
+        name: 'workspace_cancel_routine',
+        description: 'Cancel a recurring routine by its ID.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            routine_id: { type: 'string', description: 'Routine ID to cancel' },
+          },
+          required: ['routine_id'],
         },
-        required: ['routine_id'],
       },
-    },
-  );
+    );
+  }
+
+  // -- Notifications --
+  if (!disabledModules.has('notifications')) {
+    tools.push(
+      {
+        name: 'workspace_send_notification',
+        description: 'Send a notification to the workspace inbox. Use this to alert humans about completed tasks, important findings, or anything that needs their attention outside the chat stream.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            title: { type: 'string', description: 'Short notification title (e.g. "News scan complete")' },
+            message: { type: 'string', description: 'Notification body with details' },
+            priority: { type: 'string', enum: ['low', 'normal', 'high'], description: 'Notification priority (default: normal)' },
+            channel: { type: 'string', description: 'Related channel/thread name (for navigation link)' },
+          },
+          required: ['title', 'message'],
+        },
+      },
+      {
+        name: 'workspace_get_notifications',
+        description: 'List notifications you have sent to the workspace inbox.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            limit: { type: 'integer', description: 'Number of notifications to return (default 20)' },
+          },
+        },
+      },
+    );
+  }
+
+  // -- Knowledge Base --
+  if (!disabledModules.has('knowledge')) {
+    tools.push(
+      {
+        name: 'workspace_list_knowledge',
+        description: 'List knowledge base entries shared in the workspace.',
+        inputSchema: { type: 'object', properties: {} },
+      },
+      {
+        name: 'workspace_read_knowledge',
+        description: 'Read a knowledge base entry by ID or slug. Returns the full markdown content.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            entry_id: { type: 'string', description: 'Knowledge entry ID' },
+            slug: { type: 'string', description: 'Knowledge entry slug (alternative to entry_id)' },
+          },
+        },
+      },
+      {
+        name: 'workspace_write_knowledge',
+        description: 'Create or update a knowledge base entry. Knowledge entries are workspace-global markdown documents accessible to all agents via @knowledge:slug mentions.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            title: { type: 'string', description: 'Entry title' },
+            content: { type: 'string', description: 'Markdown content of the knowledge entry' },
+            description: { type: 'string', description: 'Short summary (optional)' },
+            entry_id: { type: 'string', description: 'Existing entry ID to update (omit to create new)' },
+          },
+          required: ['title', 'content'],
+        },
+      },
+      {
+        name: 'workspace_delete_knowledge',
+        description: 'Delete a knowledge base entry by ID.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            entry_id: { type: 'string', description: 'Knowledge entry ID to delete' },
+          },
+          required: ['entry_id'],
+        },
+      },
+    );
+  }
 
   return tools;
 }
@@ -760,25 +856,41 @@ class McpServer {
           {
             name: args.name,
             message: args.message,
+            context: args.context,
             hour: args.hour,
             minute: args.minute,
             days: args.days,
+            interval_minutes: args.interval_minutes,
             source: `openagents:${this.agentName}`,
           },
         );
-        const daysStr = args.days ? `days [${args.days.join(',')}]` : 'every day';
-        return text(`Routine created: "${args.name}" at ${String(args.hour).padStart(2,'0')}:${String(args.minute).padStart(2,'0')} UTC, ${daysStr} (id: ${result.id})`);
+        let scheduleStr;
+        if (args.interval_minutes != null) {
+          scheduleStr = `every ${args.interval_minutes} min`;
+        } else {
+          const daysStr = args.days ? `days [${args.days.join(',')}]` : 'every day';
+          scheduleStr = `at ${String(args.hour).padStart(2,'0')}:${String(args.minute).padStart(2,'0')} UTC, ${daysStr}`;
+        }
+        const channel = (result && result.channel_name) || `routine:${result.id}`;
+        return text(
+          `Routine created: "${args.name}" ${scheduleStr} in dedicated thread \`${channel}\` (id: ${result.id})`,
+        );
       }
 
       case 'workspace_list_routines': {
         const data = await this.ws.listRoutines(this.workspaceId, this.channelName, this.token);
         const routines = (data && data.routines) || [];
         if (!routines.length) return text('No active routines.');
-        const lines = routines.map((r) =>
-          `- ${r.id}: "${r.name}" at ${String(r.schedule_hour).padStart(2,'0')}:${String(r.schedule_minute).padStart(2,'0')} UTC` +
-          (r.schedule_days ? ` [days: ${r.schedule_days.join(',')}]` : ' (daily)') +
-          ` — next: ${r.next_fires_at} (by ${r.created_by})`
-        );
+        const lines = routines.map((r) => {
+          let when;
+          if (r.schedule_interval_minutes != null) {
+            when = `every ${r.schedule_interval_minutes} min`;
+          } else {
+            when = `at ${String(r.schedule_hour).padStart(2,'0')}:${String(r.schedule_minute).padStart(2,'0')} UTC` +
+              (r.schedule_days ? ` [days: ${r.schedule_days.join(',')}]` : ' (daily)');
+          }
+          return `- ${r.id}: "${r.name}" ${when} — next: ${r.next_fires_at} (by ${r.created_by})`;
+        });
         return text(lines.join('\n'));
       }
 
@@ -787,6 +899,82 @@ class McpServer {
         return text(`Routine cancelled: ${args.routine_id}`);
       }
 
+      case 'workspace_send_notification': {
+        const result = await this.ws.createNotification(
+          this.workspaceId, this.token,
+          {
+            title: args.title,
+            message: args.message,
+            priority: args.priority || 'normal',
+            channel: args.channel || this.channelName,
+            source: `openagents:${this.agentName}`,
+          },
+        );
+        return text(`Notification sent: "${args.title}" (id: ${result.id})`);
+      }
+
+      case 'workspace_get_notifications': {
+        const data = await this.ws.listNotifications(this.workspaceId, this.token, {
+          limit: args.limit || 20,
+        });
+        const notifications = (data && data.notifications) || [];
+        if (!notifications.length) return text('No notifications.');
+        const lines = notifications.map((n) => {
+          const readStatus = n.is_read ? '[read]' : '[unread]';
+          const prio = n.priority !== 'normal' ? ` [${n.priority}]` : '';
+          return `- ${readStatus}${prio} ${n.title}: ${n.message.slice(0, 80)}${n.message.length > 80 ? '...' : ''} (${n.created_at})`;
+        });
+        return text(lines.join('\n'));
+      }
+
+      // ── Knowledge Base ──
+
+      case 'workspace_list_knowledge': {
+        const data = await this.ws.listKnowledge(this.workspaceId, this.token);
+        const entries = (data && data.entries) || [];
+        if (!entries.length) return text('No knowledge entries yet.');
+        const lines = entries.map((e) =>
+          `- ${e.title} (slug: ${e.slug}, id: ${e.id})`
+        );
+        return text(lines.join('\n'));
+      }
+
+      case 'workspace_read_knowledge': {
+        let data;
+        if (args.slug) {
+          data = await this.ws.getKnowledgeBySlug(this.workspaceId, this.token, args.slug);
+        } else if (args.entry_id) {
+          data = await this.ws.getKnowledge(this.workspaceId, this.token, args.entry_id);
+        } else {
+          throw new Error('Either entry_id or slug is required');
+        }
+        return text(`# ${data.title}\n\n${data.content || '(empty)'}`);
+      }
+
+      case 'workspace_write_knowledge': {
+        let result;
+        if (args.entry_id) {
+          result = await this.ws.updateKnowledge(
+            this.workspaceId, this.token, args.entry_id,
+            { title: args.title, content: args.content, description: args.description,
+              source: `openagents:${this.agentName}` },
+          );
+          return text(`Knowledge updated: "${result.title}" (slug: ${result.slug})`);
+        } else {
+          result = await this.ws.createKnowledge(
+            this.workspaceId, this.token,
+            { title: args.title, content: args.content, description: args.description,
+              source: `openagents:${this.agentName}` },
+          );
+          return text(`Knowledge created: "${result.title}" (slug: ${result.slug}, id: ${result.id})`);
+        }
+      }
+
+      case 'workspace_delete_knowledge': {
+        await this.ws.deleteKnowledge(this.workspaceId, this.token, args.entry_id);
+        return text(`Knowledge entry deleted: ${args.entry_id}`);
+      }
+
       default:
         throw new Error(`Unknown tool: ${name}`);
     }

package/src/paths.js

@@ -16,12 +16,25 @@ const IS_WINDOWS = process.platform === 'win32';
 const IS_MACOS = process.platform === 'darwin';
 const SEP = IS_WINDOWS ? ';' : ':';
 const HOME = process.env.HOME || process.env.USERPROFILE || '';
+const PATH_LOOKUP_CACHE_TTL_MS = 30 * 1000;
+
+let extraBinDirsCache = { value: null, at: 0, path: '' };
+const whichBinaryCache = new Map();
 
 /**
  * Get all extra binary directories that should be checked beyond process.env.PATH.
  * Returns deduplicated list of existing directories.
  */
 function getExtraBinDirs() {
+  const currentPATH = process.env.PATH || '';
+  if (
+    extraBinDirsCache.value &&
+    extraBinDirsCache.path === currentPATH &&
+    Date.now() - extraBinDirsCache.at < PATH_LOOKUP_CACHE_TTL_MS
+  ) {
+    return [...extraBinDirsCache.value];
+  }
+
   const dirs = [];
 
   if (IS_WINDOWS) {
@@ -62,8 +75,7 @@ function getExtraBinDirs() {
 
   // Filter to existing directories only, deduplicate
   const seen = new Set();
-  const currentPATH = process.env.PATH || '';
-  return dirs.filter(d => {
+  const value = dirs.filter(d => {
     if (!d || seen.has(d)) return false;
     // Skip if already in PATH (case-insensitive on Windows)
     if (IS_WINDOWS ? currentPATH.toLowerCase().includes(d.toLowerCase()) : currentPATH.includes(d)) return false;
@@ -74,6 +86,8 @@ function getExtraBinDirs() {
       return false;
     }
   });
+  extraBinDirsCache = { value, at: Date.now(), path: currentPATH };
+  return [...value];
 }
 
 /**
@@ -114,6 +128,13 @@ function getEnhancedEnv(baseEnv) {
  */
 function whichBinary(name) {
   if (!name) return null;
+  const currentPATH = process.env.PATH || '';
+  const cacheKey = `${name}\0${currentPATH}`;
+  const cached = whichBinaryCache.get(cacheKey);
+  if (cached && Date.now() - cached.at < PATH_LOOKUP_CACHE_TTL_MS) {
+    return cached.value;
+  }
+
   const cmd = IS_WINDOWS ? `where ${name}` : `which ${name}`;
   try {
     const result = execSync(cmd, {
@@ -121,9 +142,13 @@ function whichBinary(name) {
       stdio: ['pipe', 'pipe', 'pipe'],
       env: { ...process.env, PATH: getEnhancedPATH() },
       timeout: 5000,
+      windowsHide: true,
     }).trim();
-    return result.split(/\r?\n/)[0] || null;
+    const value = result.split(/\r?\n/)[0] || null;
+    whichBinaryCache.set(cacheKey, { value, at: Date.now() });
+    return value;
   } catch {
+    whichBinaryCache.set(cacheKey, { value: null, at: Date.now() });
     return null;
   }
 }
@@ -154,6 +179,9 @@ function _addWindowsPaths(dirs) {
   // Portable Node.js installed by OpenAgents Launcher
   _push(dirs, path.join(HOME, '.openagents', 'nodejs'));
 
+  // Cursor CLI native installer
+  _push(dirs, path.join(HOME, '.cursor', 'bin'));
+
   // Node.js install
   _push(dirs, path.join(programFiles, 'nodejs'));
 

package/src/registry.js

@@ -85,7 +85,7 @@ class Registry {
 
   /**
    * Merge bundled env_config/resolve_env/install into catalog entries.
-   * Remote/cached entries may lack these fields.
+   * Remote/cached entries may lack these fields or carry stale install data.
    */
   _mergeBundled(catalog) {
     const bundled = this._loadBundled();
@@ -94,7 +94,7 @@ class Registry {
       if (b) {
         if ((!entry.env_config || entry.env_config.length === 0) && b.env_config && b.env_config.length > 0) entry.env_config = b.env_config;
         if (!entry.resolve_env && b.resolve_env) entry.resolve_env = b.resolve_env;
-        if (!entry.install && b.install) entry.install = b.install;
+        if (b.install) entry.install = { ...b.install };
         if (!entry.check_ready && b.check_ready) entry.check_ready = b.check_ready;
         if (!entry.launch && b.launch) entry.launch = b.launch;
         // Always take featured/order/support from bundled (source of truth for ordering)
@@ -136,11 +136,11 @@ class Registry {
     const catalog = this.getCatalogSync();
     const entry = catalog.find((e) => e.name === agentType) || null;
     if (!entry) return null;
-    // Merge missing fields from bundled registry
+    // Merge bundled registry fields into cached/remote entries.
     const bundled = this._loadBundled();
     const b = bundled.find((e) => e.name === agentType);
     if (b) {
-      if (!entry.install && b.install) entry.install = b.install;
+      if (b.install) entry.install = { ...b.install };
       if (!entry.check_ready && b.check_ready) entry.check_ready = b.check_ready;
       if (!entry.launch && b.launch) entry.launch = b.launch;
       if ((!entry.env_config || !entry.env_config.length) && b.env_config?.length) entry.env_config = b.env_config;

package/src/skill-catalog.js

@@ -0,0 +1,125 @@
+'use strict';
+
+/**
+ * Skill Hub catalog — JavaScript mirror of the backend skill_catalog.py.
+ *
+ * Provides the same skill definitions and conversion helpers so the
+ * launcher CLI and daemon can work offline without hitting the backend.
+ */
+
+const SKILL_CATALOG = [
+  {
+    id: 'workspace-core',
+    name: 'Workspace Core',
+    description: 'Messaging, agent discovery, and status — always available',
+    category: 'core',
+    icon: 'message-square',
+    moduleKey: null,
+    defaultEnabled: true,
+    toggleable: false,
+  },
+  {
+    id: 'files',
+    name: 'Shared Files',
+    description: 'Upload, download, and share files across workspace agents and users',
+    category: 'collaboration',
+    icon: 'file-text',
+    moduleKey: 'files',
+    defaultEnabled: true,
+    toggleable: true,
+  },
+  {
+    id: 'browser',
+    name: 'Shared Browser',
+    description: 'Browse websites through the workspace\'s shared browser session',
+    category: 'collaboration',
+    icon: 'globe',
+    moduleKey: 'browser',
+    defaultEnabled: true,
+    toggleable: true,
+  },
+  {
+    id: 'tunnel',
+    name: 'Cloudflare Tunnel',
+    description: 'Expose local services to the internet via secure tunnels',
+    category: 'collaboration',
+    icon: 'cloud',
+    moduleKey: 'tunnel',
+    defaultEnabled: true,
+    toggleable: true,
+  },
+  {
+    id: 'todos',
+    name: 'Task Planning',
+    description: 'Create and manage to-do lists for coordinated agent work',
+    category: 'productivity',
+    icon: 'check-square',
+    moduleKey: 'todos',
+    defaultEnabled: true,
+    toggleable: true,
+  },
+  {
+    id: 'timers',
+    name: 'Timers',
+    description: 'Set countdown timers with callback messages',
+    category: 'productivity',
+    icon: 'timer',
+    moduleKey: 'timers',
+    defaultEnabled: true,
+    toggleable: true,
+  },
+  {
+    id: 'routines',
+    name: 'Routines',
+    description: 'Schedule recurring tasks on a daily or interval basis',
+    category: 'productivity',
+    icon: 'repeat',
+    moduleKey: 'routines',
+    defaultEnabled: true,
+    toggleable: true,
+  },
+  {
+    id: 'knowledge',
+    name: 'Knowledge Base',
+    description: 'Create, read, and share knowledge base entries across workspace agents',
+    category: 'collaboration',
+    icon: 'book-open',
+    moduleKey: 'knowledge',
+    defaultEnabled: true,
+    toggleable: true,
+  },
+];
+
+const _TOGGLEABLE = SKILL_CATALOG.filter(s => s.toggleable);
+
+/**
+ * Convert a per-agent skills config object to a disabledModules Set.
+ *
+ * @param {Object.<string, boolean>|null|undefined} skills
+ * @returns {Set<string>}
+ */
+function skillsToDisabledModules(skills) {
+  if (!skills || typeof skills !== 'object') return new Set();
+
+  const disabled = new Set();
+  for (const s of _TOGGLEABLE) {
+    const enabled = skills[s.id] !== undefined ? skills[s.id] : s.defaultEnabled;
+    if (!enabled && s.moduleKey) {
+      disabled.add(s.moduleKey);
+    }
+  }
+  return disabled;
+}
+
+/**
+ * Return default skill state: {id: defaultEnabled} for all toggleable skills.
+ */
+function getSkillDefaults() {
+  const defaults = {};
+  for (const s of _TOGGLEABLE) {
+    defaults[s.id] = s.defaultEnabled;
+  }
+  return defaults;
+}
+
+module.exports = { SKILL_CATALOG, skillsToDisabledModules, getSkillDefaults };