@openagents-org/agent-launcher 0.1.17 → 0.2.2

package/package.json

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

package/registry.json

@@ -433,6 +433,7 @@
       "cli",
       "terminal"
     ],
+    "builtin": true,
     "install": {
       "binary": "opencode",
       "requires": [
@@ -441,6 +442,55 @@
       "macos": "npm install -g opencode-ai@latest",
       "linux": "npm install -g opencode-ai@latest",
       "windows": "npm install -g opencode-ai@latest"
+    },
+    "adapter": {
+      "module": "openagents.adapters.opencode",
+      "class": "OpenCodeAdapter"
+    },
+    "env_config": [
+      {
+        "name": "LLM_API_KEY",
+        "description": "API key",
+        "required": true,
+        "password": true
+      },
+      {
+        "name": "LLM_BASE_URL",
+        "description": "API base URL (OpenAI-compatible endpoint)",
+        "required": false,
+        "default": "https://api.openai.com/v1",
+        "placeholder": "https://api.openai.com/v1"
+      },
+      {
+        "name": "LLM_MODEL",
+        "description": "Model name",
+        "required": false,
+        "placeholder": "gpt-4o, claude-sonnet-4-20250514, etc."
+      }
+    ],
+    "resolve_env": {
+      "rules": [
+        {
+          "from": "LLM_API_KEY",
+          "to": "OPENAI_API_KEY"
+        },
+        {
+          "from": "LLM_BASE_URL",
+          "to": "OPENAI_BASE_URL"
+        },
+        {
+          "from": "LLM_MODEL",
+          "to": "OPENCODE_MODEL"
+        }
+      ]
+    },
+    "check_ready": {
+      "env_vars": [
+        "OPENAI_API_KEY",
+        "ANTHROPIC_API_KEY"
+      ],
+      "saved_env_key": "LLM_API_KEY",
+      "not_ready_message": "Not configured — press e to configure"
     }
   },
   {

package/src/adapters/claude.js

@@ -106,6 +106,7 @@ class ClaudeAdapter extends BaseAdapter {
   }
 
   _findClaudeBinary() {
+    // Tier 1: PATH search
     try {
       if (IS_WINDOWS) {
         const r = execSync('where claude.cmd 2>nul || where claude.exe 2>nul || where claude 2>nul', {
@@ -115,9 +116,29 @@ class ClaudeAdapter extends BaseAdapter {
       } else {
         return execSync('which claude', { encoding: 'utf-8', timeout: 5000 }).trim();
       }
-    } catch {
-      return null;
+    } catch {}
+
+    // Tier 2: Next to current Node.js interpreter (npm global)
+    const nodeBinDir = path.dirname(process.execPath);
+    const ext = IS_WINDOWS ? '.cmd' : '';
+    const nearNode = path.join(nodeBinDir, `claude${ext}`);
+    if (fs.existsSync(nearNode)) return nearNode;
+
+    // Tier 3: Common install locations
+    const home = os.homedir();
+    const candidates = IS_WINDOWS ? [
+      path.join(process.env.APPDATA || '', 'npm', 'claude.cmd'),
+    ] : [
+      path.join(home, '.local', 'bin', 'claude'),
+      path.join(home, '.npm-global', 'bin', 'claude'),
+      '/opt/homebrew/bin/claude',
+      '/usr/local/bin/claude',
+    ];
+    for (const c of candidates) {
+      if (fs.existsSync(c)) return c;
     }
+
+    return null;
   }
 
   _buildClaudeCmd(prompt, channelName) {
@@ -197,8 +218,9 @@ class ClaudeAdapter extends BaseAdapter {
     if (this.disabledModules.has('files')) mcpArgs.push('--disable-files');
     if (this.disabledModules.has('browser')) mcpArgs.push('--disable-browser');
 
-    // Find openagents binary
-    let oaBin;
+    // Find openagents binary (multi-tier)
+    let oaBin = null;
+    // Tier 1: PATH
     try {
       if (IS_WINDOWS) {
         oaBin = execSync('where openagents.cmd 2>nul || where openagents.exe 2>nul || where openagents 2>nul', {
@@ -207,7 +229,31 @@ class ClaudeAdapter extends BaseAdapter {
       } else {
         oaBin = execSync('which openagents', { encoding: 'utf-8', timeout: 5000 }).trim();
       }
-    } catch {
+    } catch {}
+    // Tier 2: Next to Node.js
+    if (!oaBin) {
+      const nodeBinDir2 = path.dirname(process.execPath);
+      const oaExt = IS_WINDOWS ? '.cmd' : '';
+      const nearNode2 = path.join(nodeBinDir2, `openagents${oaExt}`);
+      if (fs.existsSync(nearNode2)) oaBin = nearNode2;
+    }
+    // Tier 3: Common locations
+    if (!oaBin) {
+      const home2 = os.homedir();
+      const oaCandidates = IS_WINDOWS ? [
+        path.join(process.env.APPDATA || '', 'npm', 'openagents.cmd'),
+      ] : [
+        path.join(home2, '.openagents', 'npm-global', 'bin', 'openagents'),
+        path.join(home2, '.local', 'bin', 'openagents'),
+        path.join(home2, '.npm-global', 'bin', 'openagents'),
+        '/opt/homebrew/bin/openagents',
+        '/usr/local/bin/openagents',
+      ];
+      for (const c of oaCandidates) {
+        if (fs.existsSync(c)) { oaBin = c; break; }
+      }
+    }
+    if (!oaBin) {
       oaBin = 'openagents';
       this._log('Could not find openagents binary — MCP tools may not be available');
     }
@@ -309,15 +355,47 @@ class ClaudeAdapter extends BaseAdapter {
       const lastResponseText = [];
       let hasToolUseSinceLastText = false;
       let postedThinking = false;
+      let stderrBuf = '';
 
-      // Read stream-json output line by line
-      let buffer = '';
-      proc.stdout.on('data', (chunk) => { buffer += chunk.toString('utf-8'); });
+      // Capture stderr for diagnostics
+      if (proc.stderr) {
+        proc.stderr.on('data', (chunk) => { stderrBuf += chunk.toString('utf-8'); });
+      }
 
       await new Promise((resolve, reject) => {
+        let consecutiveTimeouts = 0;
+        let lastDataTime = Date.now();
+        let timeoutTimer = null;
+
+        const resetTimeout = () => {
+          consecutiveTimeouts = 0;
+          lastDataTime = Date.now();
+        };
+
+        // 15-second idle timeout monitoring
+        const startTimeoutMonitor = () => {
+          timeoutTimer = setInterval(async () => {
+            const elapsed = Date.now() - lastDataTime;
+            if (elapsed >= 15000) {
+              consecutiveTimeouts++;
+              lastDataTime = Date.now(); // reset for next interval
+              if (consecutiveTimeouts === 2) {
+                try { await this.sendStatus(msgChannel, 'Compacting conversation...'); } catch {}
+              }
+              // Kill after 20 consecutive timeouts (~5 minutes of no output)
+              if (consecutiveTimeouts >= 20) {
+                this._log(`Process idle for ${consecutiveTimeouts * 15}s, killing...`);
+                await this._stopProcess(proc);
+              }
+            }
+          }, 15000);
+        };
+        startTimeoutMonitor();
+
         const processLine = async (line) => {
           line = line.trim();
           if (!line) return;
+          resetTimeout();
 
           let event;
           try { event = JSON.parse(line); } catch { return; }
@@ -363,10 +441,14 @@ class ClaudeAdapter extends BaseAdapter {
             if (subtype.includes('compact') || String(message).toLowerCase().includes('compact')) {
               await this.sendStatus(msgChannel, String(message) || 'Compacting conversation...');
             }
+          } else if (eventType === 'rate_limit_event') {
+            this._log(`Rate limited: ${JSON.stringify(event).slice(0, 200)}`);
           }
         };
 
         proc.on('exit', async (code) => {
+          if (timeoutTimer) clearInterval(timeoutTimer);
+
           // Process remaining buffer
           const lines = buffer.split('\n');
           for (const line of lines) {
@@ -377,6 +459,9 @@ class ClaudeAdapter extends BaseAdapter {
 
           if (code !== 0) {
             this._log(`CLI exited with code ${code}`);
+            if (stderrBuf.trim()) {
+              this._log(`stderr: ${stderrBuf.trim().slice(0, 500)}`);
+            }
           }
 
           if (lastResponseText.length > 0) {
@@ -390,12 +475,16 @@ class ClaudeAdapter extends BaseAdapter {
           resolve();
         });
 
-        proc.on('error', (err) => reject(err));
+        proc.on('error', (err) => {
+          if (timeoutTimer) clearInterval(timeoutTimer);
+          reject(err);
+        });
 
         // Process lines as they arrive
         let lineBuffer = '';
         proc.stdout.on('data', (chunk) => {
           lineBuffer += chunk.toString('utf-8');
+          resetTimeout();
           const lines = lineBuffer.split('\n');
           lineBuffer = lines.pop(); // keep incomplete line
           for (const line of lines) {

package/src/adapters/cursor.js

@@ -0,0 +1,22 @@
+/**
+ * Cursor adapter — AI-powered code editor agent mode.
+ *
+ * Uses direct LLM API mode (OpenAI-compatible chat completions).
+ * Port of Python: src/openagents/adapters/cursor.py
+ */
+
+'use strict';
+
+const LlmDirectAdapter = require('./llm-direct');
+
+class CursorAdapter extends LlmDirectAdapter {
+  constructor(opts) {
+    super({
+      ...opts,
+      adapterLabel: 'Cursor',
+      modelEnvVar: 'CURSOR_MODEL',
+    });
+  }
+}
+
+module.exports = CursorAdapter;

package/src/adapters/index.js

@@ -8,16 +8,22 @@ const BaseAdapter = require('./base');
 const OpenClawAdapter = require('./openclaw');
 const ClaudeAdapter = require('./claude');
 const CodexAdapter = require('./codex');
+const OpenCodeAdapter = require('./opencode');
+const NanoClawAdapter = require('./nanoclaw');
+const CursorAdapter = require('./cursor');
 
 const ADAPTER_MAP = {
   openclaw: OpenClawAdapter,
   claude: ClaudeAdapter,
   codex: CodexAdapter,
+  opencode: OpenCodeAdapter,
+  nanoclaw: NanoClawAdapter,
+  cursor: CursorAdapter,
 };
 
 /**
  * Create an adapter instance for the given agent type.
- * @param {string} type - Agent type (openclaw, claude, codex)
+ * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor)
  * @param {object} opts - Adapter constructor options
  * @returns {BaseAdapter}
  */
@@ -34,6 +40,9 @@ module.exports = {
   OpenClawAdapter,
   ClaudeAdapter,
   CodexAdapter,
+  OpenCodeAdapter,
+  NanoClawAdapter,
+  CursorAdapter,
   createAdapter,
   ADAPTER_MAP,
 };

package/src/adapters/llm-direct.js

@@ -0,0 +1,180 @@
+/**
+ * Direct LLM API adapter — shared base for NanoClaw and Cursor.
+ *
+ * Calls OpenAI-compatible chat completions API directly with SSE streaming.
+ * No CLI binary needed — just OPENAI_API_KEY + OPENAI_BASE_URL.
+ *
+ * Port of Python: src/openagents/adapters/nanoclaw.py & cursor.py
+ */
+
+'use strict';
+
+const https = require('https');
+const http = require('http');
+
+const BaseAdapter = require('./base');
+const { formatAttachmentsForPrompt } = require('./utils');
+const { buildOpenclawSystemPrompt } = require('./workspace-prompt');
+
+const MAX_HISTORY = 50;
+
+class LlmDirectAdapter extends BaseAdapter {
+  /**
+   * @param {object} opts - BaseAdapter opts plus:
+   * @param {Set} [opts.disabledModules]
+   * @param {string} opts.adapterLabel - e.g. "NanoClaw" or "Cursor"
+   * @param {string} opts.modelEnvVar - e.g. "NANOCLAW_MODEL" or "CURSOR_MODEL"
+   */
+  constructor(opts) {
+    super(opts);
+    this.disabledModules = opts.disabledModules || new Set();
+    this._adapterLabel = opts.adapterLabel || 'LLM';
+    this._modelEnvVar = opts.modelEnvVar || '';
+
+    const env = this.agentEnv || process.env;
+    this._apiKey = env.OPENAI_API_KEY || '';
+    this._baseUrl = (env.OPENAI_BASE_URL || '').replace(/\/$/, '');
+    this._model = env[this._modelEnvVar] || env.OPENCLAW_MODEL || '';
+    this._directMode = !!(this._apiKey && this._baseUrl);
+
+    if (this._directMode) {
+      this._log(`Direct LLM mode: ${this._baseUrl} model=${this._model || 'gpt-4o'}`);
+    } else {
+      this._log(
+        `${this._adapterLabel} adapter started without direct API config. ` +
+        'Set OPENAI_API_KEY + OPENAI_BASE_URL for direct mode.'
+      );
+    }
+
+    this._conversationHistory = [];
+  }
+
+  _buildSystemPrompt(channelName) {
+    return buildOpenclawSystemPrompt({
+      agentName: this.agentName,
+      workspaceId: this.workspaceId,
+      channelName,
+      endpoint: this.endpoint,
+      token: this.token,
+      mode: this._mode,
+      disabledModules: this.disabledModules,
+    });
+  }
+
+  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)}...`);
+
+    await this._autoTitleChannel(msgChannel, content);
+    await this.sendStatus(msgChannel, 'thinking...');
+
+    try {
+      if (!this._directMode) {
+        await this.sendError(
+          msgChannel,
+          `${this._adapterLabel} direct API mode not configured. Set OPENAI_API_KEY + OPENAI_BASE_URL.`
+        );
+        return;
+      }
+
+      const responseText = await this._callCompletionApi(content, msgChannel);
+
+      if (responseText) {
+        this._conversationHistory.push({ role: 'user', content });
+        this._conversationHistory.push({ role: 'assistant', content: responseText });
+        if (this._conversationHistory.length > MAX_HISTORY * 2) {
+          this._conversationHistory = this._conversationHistory.slice(-MAX_HISTORY * 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}`);
+    }
+  }
+
+  /**
+   * Call OpenAI-compatible chat completions API with SSE streaming.
+   */
+  _callCompletionApi(userMessage, channel) {
+    const systemPrompt = this._buildSystemPrompt(channel);
+
+    const messages = [{ role: 'system', content: systemPrompt }];
+    messages.push(...this._conversationHistory);
+    messages.push({ role: 'user', content: userMessage });
+
+    const url = `${this._baseUrl}/chat/completions`;
+    const headers = {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${this._apiKey}`,
+    };
+    const payload = JSON.stringify({
+      model: this._model || 'gpt-4o',
+      messages,
+      stream: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      const parsedUrl = new URL(url);
+      const transport = parsedUrl.protocol === 'https:' ? https : http;
+
+      const req = transport.request(url, {
+        method: 'POST',
+        headers: { ...headers, 'Content-Length': Buffer.byteLength(payload) },
+        timeout: 300000,
+      }, (res) => {
+        if (res.statusCode !== 200) {
+          let body = '';
+          res.on('data', (c) => { body += c; });
+          res.on('end', () => reject(new Error(`LLM API returned ${res.statusCode}: ${body.slice(0, 300)}`)));
+          return;
+        }
+
+        let fullText = '';
+        let lineBuf = '';
+
+        res.on('data', (chunk) => {
+          lineBuf += chunk.toString('utf-8');
+          const lines = lineBuf.split('\n');
+          lineBuf = lines.pop(); // keep incomplete line
+
+          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.on('timeout', () => { req.destroy(); reject(new Error('LLM API request timed out')); });
+      req.write(payload);
+      req.end();
+    });
+  }
+}
+
+module.exports = LlmDirectAdapter;

package/src/adapters/nanoclaw.js

@@ -0,0 +1,22 @@
+/**
+ * NanoClaw adapter — lightweight containerized coding agent.
+ *
+ * Uses direct LLM API mode (OpenAI-compatible chat completions).
+ * Port of Python: src/openagents/adapters/nanoclaw.py
+ */
+
+'use strict';
+
+const LlmDirectAdapter = require('./llm-direct');
+
+class NanoClawAdapter extends LlmDirectAdapter {
+  constructor(opts) {
+    super({
+      ...opts,
+      adapterLabel: 'NanoClaw',
+      modelEnvVar: 'NANOCLAW_MODEL',
+    });
+  }
+}
+
+module.exports = NanoClawAdapter;

package/src/adapters/openclaw.js

@@ -36,10 +36,6 @@ class OpenClawAdapter extends BaseAdapter {
     this.openclawAgentId = opts.openclawAgentId || 'main';
     this.disabledModules = opts.disabledModules || new Set();
 
-    // Conversation history for multi-turn context
-    this._conversationHistory = [];
-    this._maxHistory = 50;
-
     // Find the openclaw binary
     this._openclawBinary = this._findOpenclawBinary();
     if (this._openclawBinary) {
@@ -157,11 +153,6 @@ class OpenClawAdapter extends BaseAdapter {
       const responseText = await this._runCliAgent(content, msgChannel);
 
       if (responseText) {
-        this._conversationHistory.push({ role: 'user', content });
-        this._conversationHistory.push({ role: 'assistant', content: responseText });
-        if (this._conversationHistory.length > this._maxHistory * 2) {
-          this._conversationHistory = this._conversationHistory.slice(-this._maxHistory * 2);
-        }
         await this.sendResponse(msgChannel, responseText);
       } else {
         await this.sendResponse(msgChannel, 'No response generated. Please try again.');