@openagents-org/agent-launcher 0.2.63 → 0.2.65

package/package.json

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

package/src/adapters/claude.js

@@ -226,8 +226,12 @@ class ClaudeAdapter extends BaseAdapter {
 
     // Find openagents binary (multi-tier)
     let oaBin = null;
+    const home3 = os.homedir();
+    // Tier 0: Portable install at ~/.openagents/nodejs/node_modules/.bin/
+    const oaPortable = path.join(home3, '.openagents', 'nodejs', 'node_modules', '.bin', `openagents${IS_WINDOWS ? '.cmd' : ''}`);
+    if (fs.existsSync(oaPortable)) oaBin = oaPortable;
     // Tier 1: PATH
-    try {
+    if (!oaBin) try {
       if (IS_WINDOWS) {
         oaBin = execSync('where openagents.cmd 2>nul || where openagents.exe 2>nul || where openagents 2>nul', {
           encoding: 'utf-8', timeout: 5000,

package/src/cli.js

@@ -478,6 +478,7 @@ Commands:
   workspace create [name]     Create a new workspace
   workspace join <token>      Join workspace with token
   workspace list              List configured workspaces
+  mcp-server                  Start MCP server (stdio) for workspace tools
   version                     Show version
   help                        Show this help
 
@@ -535,6 +536,23 @@ async function main() {
     workspace: () => cmdWorkspace(connector, flags, positional),
     env: () => cmdEnv(connector, flags, positional),
     'test-llm': () => cmdTestLLM(connector, flags, positional),
+    'mcp-server': () => {
+      const { runMcpServer } = require('./mcp-server');
+      const workspaceId = flags['workspace-id'] || process.env.OPENAGENTS_WORKSPACE_ID;
+      const channelName = flags['channel-name'] || process.env.OPENAGENTS_CHANNEL_NAME || 'general';
+      const agentName = flags['agent-name'] || process.env.OPENAGENTS_AGENT_NAME || 'agent';
+      const endpoint = flags.endpoint || process.env.OPENAGENTS_ENDPOINT || 'https://workspace-endpoint.openagents.org';
+      const token = process.env.OA_WORKSPACE_TOKEN || '';
+      if (!workspaceId || !token) {
+        print('Error: --workspace-id required and OA_WORKSPACE_TOKEN env var must be set');
+        process.exitCode = 1;
+        return;
+      }
+      const disabledModules = new Set();
+      if (flags['disable-files']) disabledModules.add('files');
+      if (flags['disable-browser']) disabledModules.add('browser');
+      runMcpServer({ workspaceId, channelName, agentName, endpoint, token, disabledModules });
+    },
   };
 
   const handler = commands[cmd];

package/src/mcp-server.js

@@ -0,0 +1,463 @@
+'use strict';
+
+/**
+ * MCP (Model Context Protocol) server for OpenAgents workspace tools.
+ *
+ * Implements JSON-RPC 2.0 over stdio, exposing workspace operations
+ * (history, files, browser, agents) as MCP tools that Claude Code can use.
+ *
+ * Usage:
+ *   openagents mcp-server --workspace-id <id> --channel-name <ch> --agent-name <name>
+ *
+ * The workspace token is read from the OA_WORKSPACE_TOKEN env var.
+ */
+
+const readline = require('readline');
+const { WorkspaceClient } = require('./workspace-client');
+
+// ── Tool definitions ────────────────────────────────────────────────────────
+
+function buildToolDefs(disabledModules) {
+  const tools = [
+    // -- Workspace core (always enabled) --
+    {
+      name: 'workspace_get_history',
+      description: 'Read recent messages in the current workspace channel.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          limit: { type: 'integer', description: 'Number of messages to return (default 20)', default: 20 },
+        },
+      },
+    },
+    {
+      name: 'workspace_get_agents',
+      description: 'List all agents connected to the workspace with their status.',
+      inputSchema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'workspace_status',
+      description: 'Post a short status update visible to workspace viewers (e.g. "analyzing code...").',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          status: { type: 'string', description: 'Short status description' },
+        },
+        required: ['status'],
+      },
+    },
+  ];
+
+  // -- Files module --
+  if (!disabledModules.has('files')) {
+    tools.push(
+      {
+        name: 'workspace_list_files',
+        description: 'List files shared in the workspace.',
+        inputSchema: { type: 'object', properties: {} },
+      },
+      {
+        name: 'workspace_read_file',
+        description: 'Read a shared file by its ID. Returns text content or base64 for binary.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: { type: 'string', description: 'File ID to read' },
+          },
+          required: ['file_id'],
+        },
+      },
+      {
+        name: 'workspace_write_file',
+        description: 'Write/upload a file to shared workspace storage.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            filename: { type: 'string', description: 'Filename (e.g. "report.md")' },
+            content: { type: 'string', description: 'File content (text or base64 for binary)' },
+            content_type: { type: 'string', description: 'MIME type (auto-detected from filename if omitted)' },
+          },
+          required: ['filename', 'content'],
+        },
+      },
+      {
+        name: 'workspace_delete_file',
+        description: 'Delete a shared file by its ID.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: { type: 'string', description: 'File ID to delete' },
+          },
+          required: ['file_id'],
+        },
+      },
+    );
+  }
+
+  // -- Browser module --
+  if (!disabledModules.has('browser')) {
+    tools.push(
+      {
+        name: 'workspace_browser_open',
+        description: 'Open a new shared browser tab.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            url: { type: 'string', description: 'URL to open (default: about:blank)' },
+          },
+        },
+      },
+      {
+        name: 'workspace_browser_navigate',
+        description: 'Navigate a browser tab to a URL.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            tab_id: { type: 'string', description: 'Tab ID' },
+            url: { type: 'string', description: 'URL to navigate to' },
+          },
+          required: ['tab_id', 'url'],
+        },
+      },
+      {
+        name: 'workspace_browser_click',
+        description: 'Click an element in a browser tab by CSS selector.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            tab_id: { type: 'string', description: 'Tab ID' },
+            selector: { type: 'string', description: 'CSS selector of element to click' },
+          },
+          required: ['tab_id', 'selector'],
+        },
+      },
+      {
+        name: 'workspace_browser_type',
+        description: 'Type text into an element in a browser tab.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            tab_id: { type: 'string', description: 'Tab ID' },
+            selector: { type: 'string', description: 'CSS selector of input element' },
+            text: { type: 'string', description: 'Text to type' },
+          },
+          required: ['tab_id', 'selector', 'text'],
+        },
+      },
+      {
+        name: 'workspace_browser_screenshot',
+        description: 'Take a screenshot of a browser tab. Returns a base64 PNG image.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            tab_id: { type: 'string', description: 'Tab ID' },
+          },
+          required: ['tab_id'],
+        },
+      },
+      {
+        name: 'workspace_browser_snapshot',
+        description: 'Get the accessibility tree (DOM structure) of a browser tab as text.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            tab_id: { type: 'string', description: 'Tab ID' },
+          },
+          required: ['tab_id'],
+        },
+      },
+      {
+        name: 'workspace_browser_list_tabs',
+        description: 'List all open shared browser tabs.',
+        inputSchema: { type: 'object', properties: {} },
+      },
+      {
+        name: 'workspace_browser_close',
+        description: 'Close a shared browser tab.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            tab_id: { type: 'string', description: 'Tab ID to close' },
+          },
+          required: ['tab_id'],
+        },
+      },
+    );
+  }
+
+  return tools;
+}
+
+// ── MIME type detection ─────────────────────────────────────────────────────
+
+const MIME_MAP = {
+  '.txt': 'text/plain', '.md': 'text/markdown', '.json': 'application/json',
+  '.js': 'text/javascript', '.ts': 'text/typescript', '.py': 'text/x-python',
+  '.html': 'text/html', '.css': 'text/css', '.xml': 'application/xml',
+  '.yaml': 'application/yaml', '.yml': 'application/yaml',
+  '.csv': 'text/csv', '.log': 'text/plain', '.sh': 'text/x-shellscript',
+  '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif', '.svg': 'image/svg+xml', '.pdf': 'application/pdf',
+};
+
+function detectMime(filename) {
+  const ext = (filename.match(/\.[^.]+$/) || [''])[0].toLowerCase();
+  return MIME_MAP[ext] || 'application/octet-stream';
+}
+
+function isTextMime(mime) {
+  return mime.startsWith('text/') || ['application/json', 'application/xml',
+    'application/javascript', 'application/yaml'].includes(mime);
+}
+
+// ── MCP Server ──────────────────────────────────────────────────────────────
+
+class McpServer {
+  constructor({ wsClient, workspaceId, channelName, agentName, token, disabledModules }) {
+    this.ws = wsClient;
+    this.workspaceId = workspaceId;
+    this.channelName = channelName;
+    this.agentName = agentName;
+    this.token = token;
+    this.disabledModules = disabledModules || new Set();
+    this.tools = buildToolDefs(this.disabledModules);
+  }
+
+  start() {
+    const rl = readline.createInterface({ input: process.stdin, terminal: false });
+    rl.on('line', (line) => {
+      line = line.trim();
+      if (!line) return;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        this._write(jsonRpcError(null, -32700, 'Parse error'));
+        return;
+      }
+      // Notifications (no id) — acknowledge but don't respond
+      if (msg.id === undefined || msg.id === null) return;
+      this._handleRequest(msg).catch((e) => {
+        this._write(jsonRpcError(msg.id, -32603, e.message));
+      });
+    });
+    rl.on('close', () => process.exit(0));
+    this._log('MCP server started');
+  }
+
+  async _handleRequest(msg) {
+    const { id, method, params } = msg;
+    switch (method) {
+      case 'initialize':
+        this._write(jsonRpcResponse(id, {
+          protocolVersion: '2024-11-05',
+          capabilities: { tools: {} },
+          serverInfo: { name: 'openagents-workspace', version: '1.0.0' },
+        }));
+        break;
+      case 'tools/list':
+        this._write(jsonRpcResponse(id, { tools: this.tools }));
+        break;
+      case 'tools/call':
+        await this._handleToolCall(id, params || {});
+        break;
+      default:
+        this._write(jsonRpcError(id, -32601, `Unknown method: ${method}`));
+    }
+  }
+
+  async _handleToolCall(id, { name, arguments: args = {} }) {
+    try {
+      const result = await this._dispatch(name, args);
+      this._write(jsonRpcResponse(id, result));
+    } catch (e) {
+      this._write(jsonRpcResponse(id, {
+        content: [{ type: 'text', text: `Error: ${e.message}` }],
+        isError: true,
+      }));
+    }
+  }
+
+  async _dispatch(name, args) {
+    const text = (t) => ({ content: [{ type: 'text', text: t }] });
+    const image = (data, mime) => ({ content: [{ type: 'image', data, mimeType: mime }] });
+
+    switch (name) {
+
+      // ── Workspace core ──
+
+      case 'workspace_get_history': {
+        const limit = args.limit || 20;
+        const data = await this.ws.pollMessages(this.workspaceId, this.channelName, this.token, { limit });
+        const events = data.events || data || [];
+        if (!events.length) return text('No messages yet.');
+        const lines = events.map((e) => {
+          const sender = (e.source || '').replace(/^(human|openagents):/, '');
+          const content = e.payload?.content || '';
+          const type = e.payload?.message_type || 'chat';
+          if (type === 'status') return null; // skip status updates
+          return `[${sender}] ${content}`;
+        }).filter(Boolean);
+        return text(lines.join('\n'));
+      }
+
+      case 'workspace_get_agents': {
+        const data = await this.ws.getAgents(this.workspaceId, this.token);
+        const agents = data.agents || data || [];
+        if (!agents.length) return text('No agents connected.');
+        const lines = agents.map((a) =>
+          `- ${a.name} (${a.type || 'unknown'}) — ${a.status || 'unknown'}${a.role ? ` [${a.role}]` : ''}`
+        );
+        return text(lines.join('\n'));
+      }
+
+      case 'workspace_status': {
+        await this.ws.sendMessage(this.workspaceId, this.channelName, this.token, args.status, {
+          senderType: 'agent',
+          senderName: this.agentName,
+          messageType: 'status',
+        });
+        return text(`Status updated: ${args.status}`);
+      }
+
+      // ── Files ──
+
+      case 'workspace_list_files': {
+        const data = await this.ws.listFiles(this.workspaceId, this.token, { limit: 50, offset: 0 });
+        const files = data.files || data || [];
+        if (!files.length) return text('No files shared yet.');
+        const lines = files.map((f) => {
+          const size = f.size ? `${(f.size / 1024).toFixed(1)}KB` : '?';
+          return `- ${f.filename || f.name} (id: ${f.id}, ${size}, by ${f.uploaded_by || f.source || 'unknown'})`;
+        });
+        return text(lines.join('\n'));
+      }
+
+      case 'workspace_read_file': {
+        const info = await this.ws.getFileInfo(this.token, args.file_id);
+        const buf = await this.ws.readFile(this.workspaceId, this.token, args.file_id);
+        const mime = info.content_type || 'application/octet-stream';
+        if (mime.startsWith('image/')) {
+          const b64 = Buffer.isBuffer(buf) ? buf.toString('base64') : buf;
+          return image(b64, mime);
+        }
+        // Try to decode as text
+        const str = Buffer.isBuffer(buf) ? buf.toString('utf-8') : String(buf);
+        return text(str);
+      }
+
+      case 'workspace_write_file': {
+        const mime = args.content_type || detectMime(args.filename);
+        let b64;
+        if (isTextMime(mime)) {
+          b64 = Buffer.from(args.content, 'utf-8').toString('base64');
+        } else {
+          b64 = args.content; // assume already base64
+        }
+        const result = await this.ws.uploadFile(this.workspaceId, this.token, args.filename, b64, {
+          contentType: mime,
+          source: `openagents:${this.agentName}`,
+          channelName: this.channelName,
+        });
+        const fileId = result.id || result.file_id || 'unknown';
+        return text(`File written: ${args.filename} (id: ${fileId})`);
+      }
+
+      case 'workspace_delete_file': {
+        await this.ws.deleteFile(this.workspaceId, this.token, args.file_id);
+        return text(`File deleted: ${args.file_id}`);
+      }
+
+      // ── Browser ──
+
+      case 'workspace_browser_open': {
+        const result = await this.ws.browserOpenTab(this.workspaceId, this.token, {
+          url: args.url || 'about:blank',
+          source: `openagents:${this.agentName}`,
+        });
+        const tabId = result.tab_id || result.id || 'unknown';
+        return text(`Browser tab opened: ${tabId} → ${args.url || 'about:blank'}`);
+      }
+
+      case 'workspace_browser_navigate': {
+        const result = await this.ws.browserNavigate(this.workspaceId, this.token, args.tab_id, args.url);
+        const title = result.title || '';
+        return text(`Navigated to: ${args.url}${title ? ` (title: ${title})` : ''}`);
+      }
+
+      case 'workspace_browser_click': {
+        const result = await this.ws.browserClick(this.workspaceId, this.token, args.tab_id, args.selector);
+        return text(`Clicked: ${args.selector}${result.url ? ` (url now: ${result.url})` : ''}`);
+      }
+
+      case 'workspace_browser_type': {
+        await this.ws.browserType(this.workspaceId, this.token, args.tab_id, args.selector, args.text);
+        return text(`Typed into ${args.selector}: ${args.text.slice(0, 50)}${args.text.length > 50 ? '...' : ''}`);
+      }
+
+      case 'workspace_browser_screenshot': {
+        const buf = await this.ws.browserScreenshot(this.workspaceId, this.token, args.tab_id);
+        const b64 = Buffer.isBuffer(buf) ? buf.toString('base64') : buf;
+        return image(b64, 'image/png');
+      }
+
+      case 'workspace_browser_snapshot': {
+        const snapshot = await this.ws.browserSnapshot(this.workspaceId, this.token, args.tab_id);
+        return text(typeof snapshot === 'string' ? snapshot : JSON.stringify(snapshot));
+      }
+
+      case 'workspace_browser_list_tabs': {
+        const data = await this.ws.browserListTabs(this.workspaceId, this.token);
+        const tabs = data.tabs || data || [];
+        if (!tabs.length) return text('No browser tabs open.');
+        const lines = tabs.map((t) =>
+          `- ${t.id || t.tab_id}: ${t.label || t.title || 'untitled'}\n  URL: ${t.url || 'N/A'} | by ${t.created_by || 'unknown'}`
+        );
+        return text(lines.join('\n'));
+      }
+
+      case 'workspace_browser_close': {
+        await this.ws.browserCloseTab(this.workspaceId, this.token, args.tab_id);
+        return text(`Browser tab closed: ${args.tab_id}`);
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  }
+
+  _write(json) {
+    process.stdout.write(json + '\n');
+  }
+
+  _log(msg) {
+    process.stderr.write(`[mcp] ${msg}\n`);
+  }
+}
+
+// ── JSON-RPC helpers ────────────────────────────────────────────────────────
+
+function jsonRpcResponse(id, result) {
+  return JSON.stringify({ jsonrpc: '2.0', id, result });
+}
+
+function jsonRpcError(id, code, message) {
+  return JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } });
+}
+
+// ── Entry point (called from cli.js) ────────────────────────────────────────
+
+function runMcpServer(opts) {
+  const wsClient = new WorkspaceClient(opts.endpoint);
+  const server = new McpServer({
+    wsClient,
+    workspaceId: opts.workspaceId,
+    channelName: opts.channelName,
+    agentName: opts.agentName,
+    token: opts.token,
+    disabledModules: opts.disabledModules,
+  });
+  server.start();
+}
+
+module.exports = { McpServer, runMcpServer, buildToolDefs };