@openagents-org/agent-connector 0.1.10 → 0.2.0

package/src/adapters/claude.js

@@ -0,0 +1,420 @@
+/**
+ * Claude Code adapter for OpenAgents workspace.
+ *
+ * Bridges Claude Code to an OpenAgents workspace via:
+ * - Polling loop for incoming messages
+ * - Claude CLI subprocess (stream-json) for task execution
+ * - MCP server for workspace tool access
+ *
+ * Direct port of Python: src/openagents/adapters/claude.py
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync, spawn } = require('child_process');
+
+const BaseAdapter = require('./base');
+const { formatAttachmentsForPrompt, SESSION_DEFAULT_RE, generateSessionTitle } = require('./utils');
+const { buildClaudeSystemPrompt } = require('./workspace-prompt');
+
+const IS_WINDOWS = process.platform === 'win32';
+
+class ClaudeAdapter extends BaseAdapter {
+  /**
+   * @param {object} opts - BaseAdapter opts plus:
+   * @param {Set} [opts.disabledModules]
+   * @param {string} [opts.workingDir]
+   */
+  constructor(opts) {
+    super(opts);
+    this.disabledModules = opts.disabledModules || new Set();
+    this.workingDir = opts.workingDir || undefined;
+    this._channelSessions = {}; // channel → Claude CLI session_id
+    this._channelProcesses = {}; // channel → child process
+    this._sessionsFile = path.join(
+      os.homedir(), '.openagents', 'sessions',
+      `${this.workspaceId}_${this.agentName}.json`
+    );
+    this._loadSessions();
+  }
+
+  _loadSessions() {
+    try {
+      if (fs.existsSync(this._sessionsFile)) {
+        const data = JSON.parse(fs.readFileSync(this._sessionsFile, 'utf-8'));
+        if (data && typeof data === 'object') {
+          Object.assign(this._channelSessions, data);
+          this._log(`Loaded ${Object.keys(data).length} session(s)`);
+        }
+      }
+    } catch {
+      this._log('Could not load sessions file, starting fresh');
+    }
+  }
+
+  _saveSessions() {
+    try {
+      const dir = path.dirname(this._sessionsFile);
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(this._sessionsFile, JSON.stringify(this._channelSessions));
+    } catch {}
+  }
+
+  async _onControlAction(action, _payload) {
+    if (action === 'stop') {
+      await this._stopAllProcesses();
+    }
+  }
+
+  async _stopProcess(proc) {
+    if (!proc || proc.exitCode !== null) return;
+    try {
+      if (IS_WINDOWS) {
+        try { execSync(`taskkill /F /T /PID ${proc.pid}`, { timeout: 5000 }); } catch {}
+      } else {
+        try { process.kill(-proc.pid, 'SIGTERM'); } catch {
+          proc.kill('SIGTERM');
+        }
+        await new Promise((resolve) => {
+          const timeout = setTimeout(() => {
+            try { process.kill(-proc.pid, 'SIGKILL'); } catch {
+              proc.kill('SIGKILL');
+            }
+            resolve();
+          }, 5000);
+          proc.on('exit', () => { clearTimeout(timeout); resolve(); });
+        });
+      }
+    } catch {}
+  }
+
+  async _stopAllProcesses() {
+    const entries = Object.entries(this._channelProcesses);
+    if (!entries.length) return;
+    this._log(`Stopping ${entries.length} running process(es)...`);
+    for (const [channel, proc] of entries) {
+      await this._stopProcess(proc);
+      delete this._channelProcesses[channel];
+      delete this._channelQueues[channel];
+      try {
+        await this.sendStatus(channel, 'Execution stopped by user');
+      } catch {}
+    }
+  }
+
+  _findClaudeBinary() {
+    try {
+      if (IS_WINDOWS) {
+        const r = execSync('where claude.cmd 2>nul || where claude.exe 2>nul || where claude 2>nul', {
+          encoding: 'utf-8', timeout: 5000,
+        });
+        return r.split(/\r?\n/)[0].trim();
+      } else {
+        return execSync('which claude', { encoding: 'utf-8', timeout: 5000 }).trim();
+      }
+    } catch {
+      return null;
+    }
+  }
+
+  _buildClaudeCmd(prompt, channelName) {
+    const claudeBin = this._findClaudeBinary();
+    if (!claudeBin) {
+      throw new Error('claude CLI not found. Install with: curl -fsSL https://claude.ai/install.sh | bash');
+    }
+
+    const systemPrompt = '\n' + buildClaudeSystemPrompt({
+      agentName: this.agentName,
+      workspaceId: this.workspaceId,
+      channelName,
+      mode: this._mode,
+    });
+
+    const cmd = [claudeBin, '-p', prompt, '--output-format', 'stream-json', '--verbose'];
+
+    // Mode-dependent permission and tool flags
+    const pfx = 'mcp__openagents-workspace__';
+    const mcpTools = [
+      `${pfx}workspace_get_history`,
+      `${pfx}workspace_get_agents`,
+      `${pfx}workspace_status`,
+    ];
+    const mcpWriteTools = [];
+
+    if (!this.disabledModules.has('files')) {
+      mcpTools.push(`${pfx}workspace_list_files`, `${pfx}workspace_read_file`);
+      mcpWriteTools.push(`${pfx}workspace_write_file`, `${pfx}workspace_delete_file`);
+    }
+    if (!this.disabledModules.has('browser')) {
+      mcpTools.push(
+        `${pfx}workspace_browser_list_tabs`,
+        `${pfx}workspace_browser_snapshot`,
+        `${pfx}workspace_browser_screenshot`
+      );
+      mcpWriteTools.push(
+        `${pfx}workspace_browser_open`,
+        `${pfx}workspace_browser_navigate`,
+        `${pfx}workspace_browser_click`,
+        `${pfx}workspace_browser_type`,
+        `${pfx}workspace_browser_close`
+      );
+    }
+    if (!this.disabledModules.has('tunnel')) {
+      mcpTools.push(`${pfx}tunnel_list`);
+      mcpWriteTools.push(`${pfx}tunnel_expose`, `${pfx}tunnel_close`);
+    }
+
+    let allowed;
+    if (this._mode === 'plan') {
+      cmd.push('--permission-mode', 'plan');
+      allowed = [...mcpTools, 'Read', 'Glob', 'Grep'];
+    } else {
+      cmd.push('--dangerously-skip-permissions');
+      allowed = [...mcpTools, ...mcpWriteTools, 'Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep'];
+    }
+
+    cmd.push('--append-system-prompt', systemPrompt);
+    cmd.push('--allowedTools', ...allowed);
+    cmd.push('--disallowedTools', 'AskUserQuestion');
+
+    // Resume existing conversation
+    const sessionId = this._channelSessions[channelName];
+    if (sessionId) {
+      cmd.push('--resume', sessionId);
+    }
+
+    // MCP config for workspace tools
+    const mcpArgs = [
+      'mcp-server',
+      '--workspace-id', this.workspaceId,
+      '--channel-name', channelName,
+      '--agent-name', this.agentName,
+      '--endpoint', this.endpoint,
+    ];
+    if (this.disabledModules.has('files')) mcpArgs.push('--disable-files');
+    if (this.disabledModules.has('browser')) mcpArgs.push('--disable-browser');
+
+    // Find openagents binary
+    let 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,
+        }).split(/\r?\n/)[0].trim();
+      } else {
+        oaBin = execSync('which openagents', { encoding: 'utf-8', timeout: 5000 }).trim();
+      }
+    } catch {
+      oaBin = 'openagents';
+      this._log('Could not find openagents binary — MCP tools may not be available');
+    }
+
+    const mcpConfig = {
+      mcpServers: {
+        'openagents-workspace': {
+          type: 'stdio',
+          command: oaBin,
+          args: mcpArgs,
+          env: { OA_WORKSPACE_TOKEN: this.token },
+        },
+      },
+    };
+
+    // Write MCP config to temp file (avoids cmd.exe JSON quoting issues)
+    const mcpDir = path.join(os.homedir(), '.openagents', 'mcp-configs');
+    fs.mkdirSync(mcpDir, { recursive: true });
+    const mcpFile = path.join(mcpDir, `mcp-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+    fs.writeFileSync(mcpFile, JSON.stringify(mcpConfig));
+    cmd.push('--mcp-config', mcpFile);
+
+    return { cmd, mcpConfigFile: mcpFile };
+  }
+
+  async _handleMessage(msg) {
+    let content = (msg.content || '').trim();
+    const attachments = msg.attachments || [];
+
+    const attText = formatAttachmentsForPrompt(attachments);
+    if (attText) {
+      content = content ? content + attText : attText.trim();
+    }
+
+    if (!content) return;
+
+    const msgChannel = msg.sessionId || this.channelName;
+    const sender = msg.senderName || msg.senderType || 'user';
+    this._log(`Processing message from ${sender} in ${msgChannel}: ${content.slice(0, 80)}...`);
+
+    // Auto-title + resume-from on first encounter
+    if (!this._titledSessions.has(msgChannel)) {
+      this._titledSessions.add(msgChannel);
+      try {
+        const info = await this.client.getSession(this.workspaceId, msgChannel, this.token);
+        // Resume from a previous channel's Claude session if specified
+        const resumeFrom = info.resumeFrom;
+        if (resumeFrom && !this._channelSessions[msgChannel]) {
+          const sourceSession = this._channelSessions[resumeFrom];
+          if (sourceSession) {
+            this._channelSessions[msgChannel] = sourceSession;
+            this._saveSessions();
+            this._log(`Resuming channel ${msgChannel} from ${resumeFrom}`);
+          }
+        }
+        // Auto-title
+        const title = generateSessionTitle(content);
+        if (title && !info.titleManuallySet && SESSION_DEFAULT_RE.test(info.title || '')) {
+          await this.client.updateSession(
+            this.workspaceId, msgChannel, this.token,
+            { title, autoTitle: true }
+          );
+        }
+      } catch {}
+    }
+
+    await this.sendStatus(msgChannel, 'thinking...');
+
+    let mcpConfigFile = null;
+    let cmd;
+    try {
+      const result = this._buildClaudeCmd(content, msgChannel);
+      cmd = result.cmd;
+      mcpConfigFile = result.mcpConfigFile;
+    } catch (e) {
+      await this.sendError(msgChannel, e.message);
+      return;
+    }
+
+    // Clean env
+    const cleanEnv = { ...process.env };
+    delete cleanEnv.CLAUDECODE;
+    delete cleanEnv.CLAUDE_CODE_SESSION;
+
+    try {
+      // On Windows, .cmd files need cmd.exe
+      if (IS_WINDOWS && cmd[0].toLowerCase().endsWith('.cmd')) {
+        cmd = ['cmd.exe', '/c', ...cmd];
+      }
+
+      const proc = spawn(cmd[0], cmd.slice(1), {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: cleanEnv,
+        cwd: this.workingDir,
+        detached: !IS_WINDOWS,
+      });
+      this._channelProcesses[msgChannel] = proc;
+
+      const lastResponseText = [];
+      let hasToolUseSinceLastText = false;
+      let postedThinking = false;
+
+      // Read stream-json output line by line
+      let buffer = '';
+      proc.stdout.on('data', (chunk) => { buffer += chunk.toString('utf-8'); });
+
+      await new Promise((resolve, reject) => {
+        const processLine = async (line) => {
+          line = line.trim();
+          if (!line) return;
+
+          let event;
+          try { event = JSON.parse(line); } catch { return; }
+
+          const eventType = event.type;
+
+          if (eventType === 'assistant') {
+            const blocks = (event.message || {}).content || [];
+            for (const block of blocks) {
+              if (block.type === 'text' && block.text && block.text.trim()) {
+                if (hasToolUseSinceLastText) {
+                  lastResponseText.length = 0;
+                  hasToolUseSinceLastText = false;
+                }
+                lastResponseText.push(block.text.trim());
+                postedThinking = true;
+                await this.client.sendMessage(
+                  this.workspaceId, msgChannel, this.token,
+                  block.text.trim(),
+                  { senderType: 'agent', senderName: this.agentName, messageType: 'thinking', metadata: { agent_mode: this._mode } }
+                );
+              } else if (block.type === 'tool_use') {
+                hasToolUseSinceLastText = true;
+                postedThinking = false;
+                lastResponseText.length = 0;
+                const toolName = block.name || '';
+                const toolInput = String(block.input || '').slice(0, 200);
+                await this.sendStatus(msgChannel, `**Using tool:** \`${toolName}\`\n\`\`\`\n${toolInput}\n\`\`\``);
+              }
+            }
+          } else if (eventType === 'result') {
+            const sessionId = event.session_id;
+            if (sessionId) {
+              this._channelSessions[msgChannel] = sessionId;
+              this._saveSessions();
+            }
+            if (event.is_error) {
+              this._log(`Claude error: ${String(event.result || '').slice(0, 200)}`);
+            }
+          } else if (eventType === 'system') {
+            const subtype = event.subtype || '';
+            const message = event.message || '';
+            if (subtype.includes('compact') || String(message).toLowerCase().includes('compact')) {
+              await this.sendStatus(msgChannel, String(message) || 'Compacting conversation...');
+            }
+          }
+        };
+
+        proc.on('exit', async (code) => {
+          // Process remaining buffer
+          const lines = buffer.split('\n');
+          for (const line of lines) {
+            try { await processLine(line); } catch {}
+          }
+
+          delete this._channelProcesses[msgChannel];
+
+          if (code !== 0) {
+            this._log(`CLI exited with code ${code}`);
+          }
+
+          if (lastResponseText.length > 0) {
+            const fullResponse = lastResponseText.join('\n').trim();
+            if (fullResponse) {
+              try { await this.sendResponse(msgChannel, fullResponse); } catch {}
+            }
+          } else if (!postedThinking) {
+            try { await this.sendResponse(msgChannel, 'No response generated. Please try again.'); } catch {}
+          }
+          resolve();
+        });
+
+        proc.on('error', (err) => reject(err));
+
+        // Process lines as they arrive
+        let lineBuffer = '';
+        proc.stdout.on('data', (chunk) => {
+          lineBuffer += chunk.toString('utf-8');
+          const lines = lineBuffer.split('\n');
+          lineBuffer = lines.pop(); // keep incomplete line
+          for (const line of lines) {
+            processLine(line).catch(() => {});
+          }
+        });
+        // Override buffer since we're processing in real time
+        buffer = '';
+      });
+    } catch (e) {
+      this._log(`Error handling message: ${e.message}`);
+      await this.sendError(msgChannel, `Error processing message: ${e.message}`);
+    } finally {
+      if (mcpConfigFile) {
+        try { fs.unlinkSync(mcpConfigFile); } catch {}
+      }
+      delete this._channelProcesses[msgChannel];
+    }
+  }
+}
+
+module.exports = ClaudeAdapter;

package/src/adapters/codex.js

@@ -0,0 +1,260 @@
+/**
+ * Codex adapter for OpenAgents workspace.
+ *
+ * Bridges OpenAI Codex CLI to an OpenAgents workspace via:
+ * - Direct HTTP mode for OpenAI-compatible LLM APIs (when OPENAI_API_KEY set)
+ * - Codex CLI subprocess (exec --json --full-auto) as fallback
+ *
+ * Direct port of Python: src/openagents/adapters/codex.py
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawn } = require('child_process');
+const http = require('http');
+const https = require('https');
+
+const BaseAdapter = require('./base');
+const { buildOpenclawSystemPrompt } = require('./workspace-prompt');
+
+const IS_WINDOWS = process.platform === 'win32';
+const MAX_HISTORY_ENTRIES = 50;
+
+class CodexAdapter extends BaseAdapter {
+  /**
+   * @param {object} opts - BaseAdapter opts plus:
+   * @param {Set} [opts.disabledModules]
+   */
+  constructor(opts) {
+    super(opts);
+    this.disabledModules = opts.disabledModules || new Set();
+    this._codexThreadId = null;
+
+    // Direct LLM API mode
+    this._directApiKey = process.env.OPENAI_API_KEY || '';
+    this._directBaseUrl = (process.env.OPENAI_BASE_URL || '').replace(/\/+$/, '');
+    this._directModel = process.env.CODEX_MODEL || process.env.OPENCLAW_MODEL || '';
+    this._directMode = !!(this._directApiKey && this._directBaseUrl);
+
+    if (this._directMode) {
+      this._log(`Direct LLM mode: ${this._directBaseUrl} model=${this._directModel || 'gpt-4o'}`);
+    }
+
+    // Conversation history
+    this._conversationHistory = [];
+  }
+
+  _buildSystemContext(channelName) {
+    return buildOpenclawSystemPrompt({
+      agentName: this.agentName,
+      workspaceId: this.workspaceId,
+      channelName,
+      endpoint: this.endpoint,
+      token: this.token,
+      mode: this._mode,
+      disabledModules: this.disabledModules,
+    });
+  }
+
+  // ------------------------------------------------------------------
+  // Message handler
+  // ------------------------------------------------------------------
+
+  async _handleMessage(msg) {
+    const content = (msg.content || '').trim();
+    if (!content) return;
+
+    const msgChannel = msg.sessionId || this.channelName;
+    const sender = msg.senderName || msg.senderType || 'user';
+    this._log(`Processing message from ${sender} in ${msgChannel}: ${content.slice(0, 80)}...`);
+
+    await this._autoTitleChannel(msgChannel, content);
+    await this.sendStatus(msgChannel, 'thinking...');
+
+    try {
+      let responseText;
+      if (this._directMode) {
+        responseText = await this._callCompletionApi(content, msgChannel);
+      } else {
+        responseText = await this._runCodexSubprocess(content, msgChannel);
+      }
+
+      if (responseText) {
+        this._conversationHistory.push({ role: 'user', content });
+        this._conversationHistory.push({ role: 'assistant', content: responseText });
+        if (this._conversationHistory.length > MAX_HISTORY_ENTRIES * 2) {
+          this._conversationHistory = this._conversationHistory.slice(-MAX_HISTORY_ENTRIES * 2);
+        }
+        await this.sendResponse(msgChannel, responseText);
+      } else {
+        await this.sendResponse(msgChannel, 'No response generated. Please try again.');
+      }
+    } catch (e) {
+      this._log(`Error handling message: ${e.message}`);
+      await this.sendError(msgChannel, `Error processing message: ${e.message}`);
+    }
+  }
+
+  // ------------------------------------------------------------------
+  // Direct HTTP mode (OpenAI chat completions API)
+  // ------------------------------------------------------------------
+
+  async _callCompletionApi(userMessage, channel) {
+    const systemPrompt = this._buildSystemContext(channel);
+    const messages = [{ role: 'system', content: systemPrompt }];
+    messages.push(...this._conversationHistory);
+    messages.push({ role: 'user', content: userMessage });
+
+    const url = `${this._directBaseUrl}/chat/completions`;
+    const payload = JSON.stringify({
+      model: this._directModel || 'gpt-4o',
+      messages,
+      stream: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      const parsed = new URL(url);
+      const mod = parsed.protocol === 'https:' ? https : http;
+      const req = mod.request(parsed, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this._directApiKey}`,
+          'Content-Length': Buffer.byteLength(payload),
+        },
+        timeout: 300000,
+      }, (res) => {
+        if (res.statusCode !== 200) {
+          let body = '';
+          res.on('data', (d) => { body += d; });
+          res.on('end', () => reject(new Error(`LLM API returned ${res.statusCode}: ${body.slice(0, 300)}`)));
+          return;
+        }
+
+        let fullText = '';
+        let buffer = '';
+        res.on('data', (chunk) => {
+          buffer += chunk.toString('utf-8');
+          const lines = buffer.split('\n');
+          buffer = lines.pop();
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.startsWith('data: ')) continue;
+            const data = trimmed.slice(6);
+            if (data === '[DONE]') continue;
+            try {
+              const parsed = JSON.parse(data);
+              const choices = parsed.choices || [];
+              if (choices.length > 0) {
+                const delta = choices[0].delta || {};
+                if (delta.content) fullText += delta.content;
+              }
+            } catch {}
+          }
+        });
+        res.on('end', () => resolve(fullText.trim()));
+      });
+
+      req.on('error', reject);
+      req.write(payload);
+      req.end();
+    });
+  }
+
+  // ------------------------------------------------------------------
+  // Subprocess mode (codex exec --json --full-auto)
+  // ------------------------------------------------------------------
+
+  _findCodexBinary() {
+    try {
+      if (IS_WINDOWS) {
+        const r = execSync('where codex.cmd 2>nul || where codex.exe 2>nul || where codex 2>nul', {
+          encoding: 'utf-8', timeout: 5000,
+        });
+        return r.split(/\r?\n/)[0].trim();
+      } else {
+        return execSync('which codex', { encoding: 'utf-8', timeout: 5000 }).trim();
+      }
+    } catch {
+      return null;
+    }
+  }
+
+  async _runCodexSubprocess(content, msgChannel) {
+    const codexBin = this._findCodexBinary();
+    if (!codexBin) {
+      await this.sendError(msgChannel, 'codex CLI not found. Install with: npm install -g @openai/codex');
+      return '';
+    }
+
+    const context = this._buildSystemContext(msgChannel);
+    const fullPrompt = `${context}\n\n---\n\n${content}`;
+
+    let cmd = [codexBin, 'exec'];
+    if (this._codexThreadId) {
+      cmd.push('resume', this._codexThreadId);
+    }
+    cmd.push('--json', '--full-auto', fullPrompt);
+
+    if (IS_WINDOWS && cmd[0].toLowerCase().endsWith('.cmd')) {
+      cmd = ['cmd.exe', '/c', ...cmd];
+    }
+
+    return new Promise((resolve) => {
+      const proc = spawn(cmd[0], cmd.slice(1), {
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+
+      const responseTexts = [];
+      let lineBuffer = '';
+
+      proc.stdout.on('data', async (chunk) => {
+        lineBuffer += chunk.toString('utf-8');
+        const lines = lineBuffer.split('\n');
+        lineBuffer = lines.pop();
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          let event;
+          try { event = JSON.parse(trimmed); } catch { continue; }
+
+          const eventType = event.type;
+
+          if (eventType === 'thread.started') {
+            if (event.thread_id) this._codexThreadId = event.thread_id;
+          } else if (eventType === 'item.completed') {
+            const item = event.item || {};
+            if (item.type === 'agent_message' && item.text) {
+              responseTexts.push(item.text);
+            } else if (item.type === 'command_execution') {
+              const cmdText = (item.command || '').slice(0, 200);
+              try { await this.sendStatus(msgChannel, `**Running:** \`${cmdText}\``); } catch {}
+            } else if (item.type === 'file_change') {
+              try { await this.sendStatus(msgChannel, `**Editing:** \`${item.filename || ''}\``); } catch {}
+            }
+          } else if (eventType === 'turn.failed') {
+            const error = event.error || {};
+            this._log(`Codex turn failed: ${error.message || JSON.stringify(error)}`);
+          }
+        }
+      });
+
+      proc.on('exit', (code) => {
+        if (code !== 0) {
+          this._log(`Codex CLI exited with code ${code}`);
+        }
+        resolve(responseTexts.join('\n').trim());
+      });
+
+      proc.on('error', (err) => {
+        this._log(`Codex spawn error: ${err.message}`);
+        resolve('');
+      });
+    });
+  }
+}
+
+module.exports = CodexAdapter;