@openagents-org/agent-launcher 0.2.142 → 0.2.145

package/src/adapters/claude.js

@@ -19,7 +19,7 @@ const { execSync, spawn } = require('child_process');
 const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt, SESSION_DEFAULT_RE, generateSessionTitle } = require('./utils');
 const { buildClaudeSystemPrompt, buildClaudeSkillMd } = require('./workspace-prompt');
-const { defaultAgentWorkdir, whichBinary, getEnhancedEnv } = require('../paths');
+const { defaultAgentWorkdir, whichBinary, whereBinary } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
 
@@ -37,6 +37,12 @@ class ClaudeAdapter extends BaseAdapter {
     this._channelSessions = {}; // channel → Claude CLI session_id
     this._channelProcesses = {}; // channel → child process
     this._stoppingChannels = new Set();
+    // Channels that have already announced "Execution stopped by user." for the
+    // current stop. Two paths race to post it (the control-action handler that
+    // kills the process, and the in-flight message handler that sees
+    // pp.userStopped after exit), so this dedups to a single notice. Reset when
+    // a new message starts processing in the channel.
+    this._stopNoticeSent = new Set();
     this._persistentProcs = {}; // channel → { proc, lineBuffer, pendingLines, idleTimer, messageResolve }
     this._IDLE_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
     this._WATCHDOG_INTERVAL_MS = 15_000; // 15s between checks
@@ -84,9 +90,7 @@ class ClaudeAdapter extends BaseAdapter {
         await this._stopProcess(proc);
         delete this._channelProcesses[channel];
         delete this._channelQueues[channel];
-        try {
-          await this.sendResponse(channel, 'Execution stopped by user.');
-        } catch {}
+        await this._postStopNotice(channel);
       } else {
         for (const pp of Object.values(this._persistentProcs)) pp.userStopped = true;
         await this._stopAllProcesses('Execution stopped by user.');
@@ -258,6 +262,18 @@ class ClaudeAdapter extends BaseAdapter {
     );
   }
 
+  /**
+   * Post "Execution stopped by user." at most once per channel for a given
+   * stop. The control-action handler and the in-flight message handler both
+   * race to announce a stop; without this guard the user sees it twice. The
+   * guard is reset when a new message starts processing in the channel.
+   */
+  async _postStopNotice(channel) {
+    if (!channel || this._stopNoticeSent.has(channel)) return;
+    this._stopNoticeSent.add(channel);
+    try { await this.sendResponse(channel, 'Execution stopped by user.'); } catch {}
+  }
+
   async _stopAllProcesses(completionMessage = 'Execution stopped.') {
     for (const channel of Object.keys(this._persistentProcs)) {
       this._killPersistentProc(channel);
@@ -288,7 +304,9 @@ class ClaudeAdapter extends BaseAdapter {
     for (const c of candidates) {
       if (fs.existsSync(c)) return c;
     }
-    return 'node';
+    // Fall back to the node already running this daemon (absolute, always valid).
+    // Bare 'node' can be off-PATH in a packaged daemon or CI runner.
+    return process.execPath;
   }
 
   /**
@@ -343,24 +361,13 @@ class ClaudeAdapter extends BaseAdapter {
     const portableCandidate = path.join(portableBin, `claude${ext}`);
     if (fs.existsSync(portableCandidate)) return portableCandidate;
 
-    // Tier 1: PATH search. Use the ENRICHED env so the lookup sees the same
-    // node-version-manager / homebrew / npm-global dirs the launcher adds —
-    // a packaged Electron daemon's own PATH is minimal, which is why `which
-    // claude` came up empty and the agent reported "claude CLI not found".
-    // windowsHide stops a console window from flashing.
-    try {
-      const env = getEnhancedEnv();
-      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, windowsHide: true, env,
-        });
-        const hit = r.split(/\r?\n/)[0].trim();
-        if (hit) return hit;
-      } else {
-        const hit = execSync('which claude', { encoding: 'utf-8', timeout: 5000, windowsHide: true, env }).trim();
-        if (hit) return hit;
-      }
-    } catch {}
+    // Tier 1: PATH search via a codepage-safe lookup (whereBinary forces UTF-8
+    // output + verifies existence, so a non-ASCII/Chinese username isn't mangled
+    // into an ENOENT). Uses the ENRICHED env so a packaged daemon's minimal PATH
+    // still sees the node-version-manager / homebrew / npm-global dirs the
+    // launcher adds — that's why a bare `which claude` came up empty before.
+    const viaWhere = whereBinary('claude');
+    if (viaWhere) return viaWhere;
 
     // Tier 2: Next to current Node.js interpreter (npm global)
     const nodeBinDir = path.dirname(process.execPath);
@@ -558,15 +565,9 @@ class ClaudeAdapter extends BaseAdapter {
         const oaPortable = path.join(home3, '.openagents', 'nodejs', 'node_modules', '.bin', `openagents${oaExt}`);
         if (fs.existsSync(oaPortable)) oaBin = oaPortable;
       }
-      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,
-          }).split(/\r?\n/)[0].trim();
-        } else {
-          oaBin = execSync('which openagents', { encoding: 'utf-8', timeout: 5000 }).trim();
-        }
-      } catch {}
+      // Codepage-safe lookup so a non-ASCII/Chinese username in the path isn't
+      // mangled into an ENOENT (see whereBinary).
+      if (!oaBin) oaBin = whereBinary('openagents');
       if (!oaBin) {
         this._log('Could not find openagents binary — MCP tools may not be available');
         mcpCommand = 'openagents';
@@ -805,6 +806,20 @@ class ClaudeAdapter extends BaseAdapter {
         if (pp.messageResolve) {
           pp.messageResolve({ resultEvent: event });
           pp.messageResolve = null;
+        } else {
+          // Background-triggered turn: the CLI produced output on its own after
+          // the user-initiated turn already resolved (e.g. a run_in_background
+          // task finished and fed its result back to the model). That text was
+          // streamed as `thinking` only — with no messageResolve waiting,
+          // _handleMessage never posts it as a `chat`, so the thread visually
+          // hangs on "thinking…/Working…". Finalize the accumulated text as a
+          // real answer so the turn settles on an actual message bubble.
+          const trailing = pp.lastResponseText.join('\n').trim();
+          if (trailing && !event.is_error) {
+            this._resetIdleTimer(pp.msgChannel);
+            try { await this.sendResponse(pp.msgChannel, trailing); } catch {}
+          }
+          pp.lastResponseText.length = 0;
         }
       } else if (eventType === 'system') {
         const subtype = event.subtype || '';
@@ -923,6 +938,7 @@ class ClaudeAdapter extends BaseAdapter {
 
     const msgChannel = msg.sessionId || this.channelName;
     this._stoppingChannels.delete(msgChannel);
+    this._stopNoticeSent.delete(msgChannel);
     const sender = msg.senderName || msg.senderType || 'user';
     this._log(`Processing message from ${sender} in ${msgChannel}: ${content.slice(0, 80)}...`);
 
@@ -987,7 +1003,7 @@ class ClaudeAdapter extends BaseAdapter {
       }
       if (existingPP.userStopped) {
         if (!existingPP.everPostedAnything) {
-          try { await this.sendResponse(msgChannel, 'Execution stopped by user.'); } catch {}
+          await this._postStopNotice(msgChannel);
         }
         return;
       }
@@ -1087,7 +1103,7 @@ class ClaudeAdapter extends BaseAdapter {
           this._log(`Process exited during first message (attempt ${attempt + 1}), userStopped=${pp.userStopped}`);
           if (pp.userStopped) {
             if (!pp.everPostedAnything) {
-              try { await this.sendResponse(msgChannel, 'Execution stopped by user.'); } catch {}
+              await this._postStopNotice(msgChannel);
             }
             break;
           }