@openagents-org/agent-launcher 0.2.28 → 0.2.30

package/package.json

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

package/src/adapters/openclaw.js

@@ -180,6 +180,7 @@ class OpenClawAdapter extends BaseAdapter {
       const sessionKey = `openagents-${this.workspaceId.slice(0, 8)}-${channel.slice(-8)}`;
 
       const args = [
+        '--log-level', 'trace',
         'agent', '--local',
         '--agent', this.openclawAgentId,
         '--session-id', sessionKey,
@@ -230,92 +231,147 @@ class OpenClawAdapter extends BaseAdapter {
         }
       };
 
-      // Try node-pty for line-buffered output (real-time tool streaming)
-      let pty;
-      try { pty = require('node-pty'); } catch {}
-
-      if (pty) {
-        // On Windows, .cmd files can't be spawned directly by pty — use cmd.exe
-        const ptyBin = IS_WINDOWS ? (process.env.COMSPEC || 'cmd.exe') : binary;
-        const ptyArgs = IS_WINDOWS ? ['/C', binary, ...args] : args;
-        this._log('Spawn: node-pty (line-buffered)');
-        const proc = pty.spawn(ptyBin, ptyArgs, {
-          name: 'xterm',
-          cols: 200,
-          rows: 50,
-          cwd: process.cwd(),
-          env: spawnEnv,
-        });
-
-        proc.onData((data) => {
-          output += data;
-          lineBuffer += data;
-          const lines = lineBuffer.split('\n');
-          lineBuffer = lines.pop() || '';
-          for (const line of lines) processLine(line);
-        });
-
-        const timeout = setTimeout(() => {
-          proc.kill();
-          reject(new Error('CLI timed out after 600 seconds'));
-        }, 600000);
-
-        proc.onExit(({ exitCode }) => {
-          clearTimeout(timeout);
-          // Process remaining buffer
-          if (lineBuffer) processLine(lineBuffer);
-
-          if (exitCode !== 0) {
-            reject(new Error(`CLI exited ${exitCode}: ${output.slice(-300)}`));
-            return;
+      // Redirect stderr to temp file for real-time tool status polling.
+      // --log-level trace makes OpenClaw write diagnostic events to stderr
+      // even in non-TTY mode. We poll the temp file for new lines every 500ms.
+      const stderrFile = path.join(os.tmpdir(), `openclaw-stderr-${Date.now()}.log`);
+      const stderrFd = fs.openSync(stderrFile, 'w');
+      this._log('Spawn: stderr → ' + stderrFile);
+
+      let spawnBin = binary;
+      let spawnArgs = args;
+      if (IS_WINDOWS) {
+        spawnBin = process.env.COMSPEC || 'cmd.exe';
+        spawnArgs = ['/C', binary, ...args.map(a => a.includes(' ') ? `"${a}"` : a)];
+      }
+      const proc = spawn(spawnBin, spawnArgs, {
+        stdio: ['ignore', 'pipe', stderrFd],
+        env: spawnEnv,
+        timeout: 600000,
+        windowsHide: true,
+      });
+      if (proc.stdout) proc.stdout.on('data', (d) => { output += d; });
+
+      // Poll stderr file every 500ms for tool events
+      let stderrOffset = 0;
+      const pollInterval = setInterval(() => {
+        try {
+          const stat = fs.statSync(stderrFile);
+          if (stat.size > stderrOffset) {
+            const fd = fs.openSync(stderrFile, 'r');
+            const buf = Buffer.alloc(stat.size - stderrOffset);
+            fs.readSync(fd, buf, 0, buf.length, stderrOffset);
+            fs.closeSync(fd);
+            stderrOffset = stat.size;
+            const chunk = buf.toString('utf-8');
+            const lines = chunk.split('\n');
+            for (const line of lines) processLine(line);
           }
-          this._parseCliOutput(output, resolve);
-        });
-      } else {
-        // Fallback: regular spawn (buffered on Windows)
-        this._log('Spawn: fallback (no node-pty)');
-        let spawnBin = binary;
-        let spawnArgs = args;
-        if (IS_WINDOWS) {
-          spawnBin = process.env.COMSPEC || 'cmd.exe';
-          spawnArgs = ['/C', binary, ...args.map(a => a.includes(' ') ? `"${a}"` : a)];
-        }
-        const proc = spawn(spawnBin, spawnArgs, {
-          stdio: ['ignore', 'pipe', 'pipe'],
-          env: spawnEnv,
-          timeout: 600000,
-          windowsHide: true,
-        });
-        if (proc.stdout) proc.stdout.on('data', (d) => { output += d; });
-        if (proc.stderr) proc.stderr.on('data', (d) => { output += d; });
-        proc.on('error', (err) => reject(err));
-        proc.on('exit', (code) => {
-          if (code !== 0) {
-            reject(new Error(`CLI exited ${code}: ${output.slice(-300)}`));
-            return;
+        } catch {}
+      }, 500);
+
+      const killTimeout = setTimeout(() => {
+        proc.kill();
+        reject(new Error('CLI timed out after 600 seconds'));
+      }, 600000);
+
+      proc.on('error', (err) => {
+        clearInterval(pollInterval);
+        clearTimeout(killTimeout);
+        fs.closeSync(stderrFd);
+        try { fs.unlinkSync(stderrFile); } catch {}
+        reject(err);
+      });
+      proc.on('exit', (code) => {
+        clearInterval(pollInterval);
+        clearTimeout(killTimeout);
+        fs.closeSync(stderrFd);
+        // Read full stderr content (contains JSON output + trace lines)
+        let stderrContent = '';
+        try {
+          stderrContent = fs.readFileSync(stderrFile, 'utf-8');
+          // Process any remaining lines for tool events
+          const remaining = stderrContent.slice(stderrOffset);
+          if (remaining) {
+            for (const line of remaining.split('\n')) processLine(line);
           }
-          this._parseCliOutput(output, resolve);
-        });
-      }
+        } catch {}
+        try { fs.unlinkSync(stderrFile); } catch {}
+
+        // OpenClaw --json writes JSON to stderr, so combine stdout + stderr
+        const allOutput = output + '\n' + stderrContent;
+
+        if (code !== 0) {
+          reject(new Error(`CLI exited ${code}: ${allOutput.slice(-300)}`));
+          return;
+        }
+        this._parseCliOutput(allOutput, resolve);
+      });
     });
   }
 
   _parseCliOutput(output, resolve) {
     const text = output.trim();
     if (!text) { resolve(''); return; }
-    const jsonStart = text.indexOf('{');
-    if (jsonStart < 0) { resolve(text); return; }
-    try {
-      const data = JSON.parse(text.slice(jsonStart));
-      const payloads = data.payloads || [];
-      if (payloads.length > 0) {
-        resolve(payloads.filter(p => p.text).map(p => p.text).join('\n\n'));
-      } else {
-        resolve('');
+
+    // OpenClaw --json outputs a JSON blob with {"payloads":[...]} structure.
+    // With --log-level trace, stderr also contains diagnostic lines.
+    // Find the JSON by looking for '{"payloads"' or the last complete JSON object.
+    let jsonStr = null;
+
+    // Strategy 1: find {"payloads" directly
+    const payloadsIdx = text.indexOf('{"payloads"');
+    if (payloadsIdx >= 0) {
+      // Find the matching closing brace by counting braces
+      let depth = 0;
+      for (let i = payloadsIdx; i < text.length; i++) {
+        if (text[i] === '{') depth++;
+        else if (text[i] === '}') { depth--; if (depth === 0) { jsonStr = text.slice(payloadsIdx, i + 1); break; } }
+      }
+    }
+
+    // Strategy 2: find last '{' that starts a valid JSON with "payloads"
+    if (!jsonStr) {
+      for (let i = text.length - 1; i >= 0; i--) {
+        if (text[i] === '{') {
+          const candidate = text.slice(i);
+          try {
+            const d = JSON.parse(candidate);
+            if (d.payloads) { jsonStr = candidate; break; }
+          } catch {}
+        }
+      }
+    }
+
+    // Strategy 3: try each line that starts with '{'
+    if (!jsonStr) {
+      for (const line of text.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('{')) {
+          try {
+            const d = JSON.parse(trimmed);
+            if (d.payloads) { jsonStr = trimmed; break; }
+          } catch {}
+        }
       }
-    } catch {
-      resolve(text);
     }
+
+    if (jsonStr) {
+      try {
+        const data = JSON.parse(jsonStr);
+        const payloads = data.payloads || [];
+        if (payloads.length > 0) {
+          resolve(payloads.filter(p => p.text).map(p => p.text).join('\n\n'));
+          return;
+        }
+      } catch {}
+    }
+
+    // Fallback: return non-diagnostic text
+    const cleanLines = text.split('\n').filter(l =>
+      !l.includes('[diagnostic]') && !l.includes('[agent/embedded]') && !l.includes('Registered plugin')
+    ).map(l => l.trim()).filter(Boolean);
+    resolve(cleanLines.join('\n') || '');
   }
   // ------------------------------------------------------------------
   // Static: configure OpenClaw's native auth from LLM env vars