@openagents-org/agent-launcher 0.2.68 → 0.2.71

package/package.json

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

package/src/adapters/base.js

@@ -313,6 +313,17 @@ class BaseAdapter {
     } catch {}
   }
 
+  async sendThinking(channel, content) {
+    try {
+      await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
+        senderType: 'agent',
+        senderName: this.agentName,
+        messageType: 'thinking',
+        metadata: { agent_mode: this._mode },
+      });
+    } catch {}
+  }
+
   async sendResponse(channel, content) {
     await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
       senderType: 'agent',

package/src/adapters/claude.js

@@ -192,7 +192,7 @@ class ClaudeAdapter extends BaseAdapter {
     return null;
   }
 
-  _buildClaudeCmd(prompt, channelName) {
+  _buildClaudeCmd(prompt, channelName, { skipResume = false } = {}) {
     const claudeBin = this._findClaudeBinary();
     if (!claudeBin) {
       throw new Error('claude CLI not found. Install with: curl -fsSL https://claude.ai/install.sh | bash');
@@ -252,9 +252,9 @@ class ClaudeAdapter extends BaseAdapter {
     cmd.push('--allowedTools', ...allowed);
     cmd.push('--disallowedTools', 'AskUserQuestion');
 
-    // Resume existing conversation
+    // Resume existing conversation (skipped on retry after stale session)
     const sessionId = this._channelSessions[channelName];
-    if (sessionId) {
+    if (sessionId && !skipResume) {
       cmd.push('--resume', sessionId);
     }
 
@@ -389,20 +389,25 @@ class ClaudeAdapter extends BaseAdapter {
 
     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 = { ...(this.agentEnv || process.env) };
     delete cleanEnv.CLAUDECODE;
     delete cleanEnv.CLAUDE_CODE_SESSION;
 
+    // Run up to 2 attempts: first with session resume, then fresh if stale session detected
+    let _shouldRetry = false;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      if (mcpConfigFile) { try { fs.unlinkSync(mcpConfigFile); } catch {} mcpConfigFile = null; }
+      try {
+        const built = this._buildClaudeCmd(content, msgChannel, { skipResume: attempt > 0 });
+        cmd = built.cmd;
+        mcpConfigFile = built.mcpConfigFile;
+      } catch (e) {
+        await this.sendError(msgChannel, e.message);
+        return;
+      }
+
     try {
       // Always resolve shim/symlink to node + JS entry point.
       // On Windows: .cmd shims need cmd.exe which creates visible windows.
@@ -434,7 +439,7 @@ class ClaudeAdapter extends BaseAdapter {
         proc.stderr.on('data', (chunk) => { stderrBuf += chunk.toString('utf-8'); });
       }
 
-      await new Promise((resolve, reject) => {
+      _shouldRetry = await new Promise((resolve, reject) => {
         let consecutiveTimeouts = 0;
         let lastDataTime = Date.now();
         let timeoutTimer = null;
@@ -484,6 +489,8 @@ class ClaudeAdapter extends BaseAdapter {
                 }
                 lastResponseText.push(block.text.trim());
                 postedThinking = true;
+                // Stream text in real-time as "thinking" (same as Python adapter)
+                try { await this.sendThinking(msgChannel, block.text.trim()); } catch {}
               } else if (block.type === 'tool_use') {
                 hasToolUseSinceLastText = true;
                 postedThinking = false;
@@ -550,10 +557,19 @@ class ClaudeAdapter extends BaseAdapter {
             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(false); // done, no retry
+          } else if (code !== 0 && this._channelSessions[msgChannel]) {
+            // No output + error exit + had a resume session → stale session, signal retry
+            this._log(`Stale session detected for ${msgChannel}, clearing and retrying without resume`);
+            delete this._channelSessions[msgChannel];
+            this._saveSessions();
+            resolve(true); // retry=true
+          } else {
+            if (!postedThinking) {
+              try { await this.sendResponse(msgChannel, 'No response generated. Please try again.'); } catch {}
+            }
+            resolve(false);
           }
-          resolve();
         });
 
         proc.on('error', (err) => {
@@ -575,12 +591,15 @@ class ClaudeAdapter extends BaseAdapter {
     } 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];
+      break; // no retry on spawn error
+    }
+    if (!_shouldRetry) break; // exit loop if no retry needed
+    } // end for attempt
+
+    if (mcpConfigFile) {
+      try { fs.unlinkSync(mcpConfigFile); } catch {}
     }
+    delete this._channelProcesses[msgChannel];
   }
 }
 

package/src/daemon.js

@@ -408,6 +408,7 @@ class Daemon {
         openclawAgentId: agentCfg.openclaw_agent_id || 'main',
         disabledModules: new Set(),
         agentEnv: this._buildAgentEnv(agentCfg),
+        workingDir: agentCfg.path || undefined,
       });
     } catch (e) {
       this._log(`${name} failed to create ${agentType} adapter: ${e.message}`);

package/src/installer.js

@@ -163,6 +163,16 @@ class Installer {
           }
         } catch {}
       }
+      // Also check OAuth credentials (Claude Code stores tokens in .credentials.json)
+      if (!ready) {
+        try {
+          const oauthFile = path.join(os.homedir(), '.claude', '.credentials.json');
+          if (fs.existsSync(oauthFile)) {
+            const creds = JSON.parse(fs.readFileSync(oauthFile, 'utf-8'));
+            if (creds.claudeAiOauth?.accessToken) ready = true;
+          }
+        } catch {}
+      }
     }
 
     return { installed: true, binary, version, ready };

package/src/mcp-server.js

@@ -13,8 +13,13 @@
  */
 
 const readline = require('readline');
+const { execSync, spawn: spawnChild } = require('child_process');
+const net = require('net');
 const { WorkspaceClient } = require('./workspace-client');
 
+// Active tunnels: port → { proc, url }
+const _activeTunnels = {};
+
 // ── Tool definitions ────────────────────────────────────────────────────────
 
 function buildToolDefs(disabledModules) {
@@ -185,6 +190,42 @@ function buildToolDefs(disabledModules) {
     );
   }
 
+  // -- Tunnel module --
+  if (!disabledModules.has('tunnel')) {
+    tools.push(
+      {
+        name: 'tunnel_expose',
+        description:
+          'Expose a local port as a public URL via Cloudflare tunnel. ' +
+          'Use this to let workspace users preview a local dev server ' +
+          '(e.g. React, Next.js, Flask on localhost). Returns the public URL.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            port: { type: 'integer', description: 'Local port to expose (e.g. 3000)' },
+          },
+          required: ['port'],
+        },
+      },
+      {
+        name: 'tunnel_close',
+        description: 'Close a tunnel that was previously opened with tunnel_expose.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            port: { type: 'integer', description: 'Port of the tunnel to close' },
+          },
+          required: ['port'],
+        },
+      },
+      {
+        name: 'tunnel_list',
+        description: 'List all active tunnels.',
+        inputSchema: { type: 'object', properties: {} },
+      },
+    );
+  }
+
   return tools;
 }
 
@@ -196,6 +237,10 @@ const MIME_MAP = {
   '.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',
+  '.toml': 'application/toml', '.rs': 'text/x-rust', '.go': 'text/x-go',
+  '.java': 'text/x-java', '.rb': 'text/x-ruby', '.c': 'text/x-c',
+  '.cpp': 'text/x-c++', '.h': 'text/x-c', '.tsx': 'text/typescript',
+  '.jsx': 'text/javascript', '.sql': 'application/sql',
   '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
   '.gif': 'image/gif', '.svg': 'image/svg+xml', '.pdf': 'application/pdf',
 };
@@ -421,6 +466,100 @@ class McpServer {
         return text(`Browser tab closed: ${args.tab_id}`);
       }
 
+      // ── Tunnel ──
+
+      case 'tunnel_expose': {
+        const port = args.port;
+        if (!port) throw new Error('port is required');
+
+        if (_activeTunnels[port]) {
+          return text(`Tunnel already open for port ${port}: ${_activeTunnels[port].url}`);
+        }
+
+        // Check cloudflared is available
+        let cfBin;
+        try {
+          cfBin = execSync('which cloudflared 2>/dev/null || echo ""', { encoding: 'utf-8' }).trim();
+        } catch {}
+        if (!cfBin) {
+          return text(
+            'Error: cloudflared is not installed. Install it:\n' +
+            '  macOS:  brew install cloudflared\n' +
+            '  Linux:  curl -fsSL https://github.com/cloudflare/cloudflared/' +
+            'releases/latest/download/cloudflared-linux-amd64 ' +
+            '-o /usr/local/bin/cloudflared && chmod +x /usr/local/bin/cloudflared'
+          );
+        }
+
+        // Pre-flight: check port is listening
+        const portOpen = await new Promise((resolve) => {
+          const sock = new net.Socket();
+          sock.setTimeout(2000);
+          sock.on('connect', () => { sock.destroy(); resolve(true); });
+          sock.on('error', () => resolve(false));
+          sock.on('timeout', () => { sock.destroy(); resolve(false); });
+          sock.connect(port, 'localhost');
+        });
+        if (!portOpen) {
+          return text(`Error: nothing is listening on localhost:${port}. Start a server on that port first.`);
+        }
+
+        // Start cloudflared
+        const proc = spawnChild('cloudflared', ['tunnel', '--url', `http://localhost:${port}`], {
+          stdio: ['ignore', 'pipe', 'pipe'],
+          detached: true,
+        });
+
+        // Wait for URL from stderr (cloudflared logs the URL there)
+        const url = await new Promise((resolve, reject) => {
+          const urlRe = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
+          let buf = '';
+          const timeout = setTimeout(() => {
+            proc.kill();
+            reject(new Error('cloudflared did not produce a URL within 20 seconds'));
+          }, 20000);
+
+          const onData = (chunk) => {
+            buf += chunk.toString();
+            const match = buf.match(urlRe);
+            if (match) {
+              clearTimeout(timeout);
+              proc.stderr.removeListener('data', onData);
+              resolve(match[0]);
+            }
+          };
+          proc.stderr.on('data', onData);
+          proc.on('exit', (code) => {
+            clearTimeout(timeout);
+            reject(new Error(`cloudflared exited with code ${code}: ${buf.slice(0, 200)}`));
+          });
+        });
+
+        _activeTunnels[port] = { proc, url };
+        proc.unref(); // don't block MCP server exit
+        return text(`Tunnel open: localhost:${port} → ${url}`);
+      }
+
+      case 'tunnel_close': {
+        const port = args.port;
+        const tunnel = _activeTunnels[port];
+        if (!tunnel) return text(`No tunnel open for port ${port}`);
+        try { tunnel.proc.kill(); } catch {}
+        delete _activeTunnels[port];
+        return text(`Tunnel closed for port ${port}`);
+      }
+
+      case 'tunnel_list': {
+        const ports = Object.keys(_activeTunnels);
+        if (!ports.length) return text('No active tunnels.');
+        const lines = ports.map((p) => {
+          const t = _activeTunnels[p];
+          const running = t.proc && t.proc.exitCode === null;
+          return `- localhost:${p} → ${t.url} (${running ? 'running' : 'stopped'})`;
+        });
+        return text(lines.join('\n'));
+      }
+
       default:
         throw new Error(`Unknown tool: ${name}`);
     }