@openagents-org/agent-launcher 0.2.141 → 0.2.143

package/package.json

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

package/src/adapters/base.js

@@ -93,7 +93,10 @@ class BaseAdapter {
 
     // Sync workspace-managed skills into disabledModules
     try {
-      const agents = await this.client.getAgents(this.workspaceId, this.token);
+      const agents = await Promise.race([
+        this.client.getAgents(this.workspaceId, this.token),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('skill sync timed out (10s)')), 10000)),
+      ]);
       const self = agents.find((a) => a.agentName === this.agentName);
       if (self && self.enabledSkills) {
         const { skillsToDisabledModules } = require('../skill-catalog');

package/src/adapters/claude.js

@@ -73,6 +73,10 @@ class ClaudeAdapter extends BaseAdapter {
   async _onControlAction(action, payload) {
     if (action === 'stop') {
       const channel = (payload && typeof payload === 'object') ? payload.channel : null;
+      if (channel) {
+        const pp = this._persistentProcs[channel];
+        if (pp) pp.userStopped = true;
+      }
       if (channel && this._channelProcesses[channel]) {
         this._log(`Stopping process for channel=${channel}`);
         this._stoppingChannels.add(channel);
@@ -84,6 +88,7 @@ class ClaudeAdapter extends BaseAdapter {
           await this.sendResponse(channel, 'Execution stopped by user.');
         } catch {}
       } else {
+        for (const pp of Object.values(this._persistentProcs)) pp.userStopped = true;
         await this._stopAllProcesses('Execution stopped by user.');
       }
       return;
@@ -226,7 +231,7 @@ class ClaudeAdapter extends BaseAdapter {
    */
   async _buildChannelRecap(channelName, currentMessage) {
     const messages = await this.client.getRecentMessages(
-      this.workspaceId, channelName, this.token, 30
+      this.workspaceId, channelName, this.token, 60
     );
     if (!messages || messages.length === 0) return null;
 
@@ -236,20 +241,16 @@ class ClaudeAdapter extends BaseAdapter {
       if (mt === 'status' || mt === 'thinking' || mt === 'loading') continue;
       const text = (m.content || '').trim();
       if (!text) continue;
-      // Don't echo the user's current message back at them.
       if (text === currentMessage) continue;
       const who = m.senderType === 'human'
         ? (m.senderName || 'user')
         : (m.senderName || 'agent');
-      // Cap each line so a single huge paste doesn't blow up the prompt.
-      const truncated = text.length > 800 ? text.slice(0, 800) + '…' : text;
+      const truncated = text.length > 2000 ? text.slice(0, 2000) + '…' : text;
       lines.push(`[${who}] ${truncated}`);
     }
     if (lines.length === 0) return null;
 
-    // Keep only the tail; older context has diminishing value and we
-    // don't want to balloon the system prompt.
-    const tail = lines.slice(-15).join('\n');
+    const tail = lines.slice(-20).join('\n');
     return (
       'You previously worked in this channel but your prior session is no ' +
       'longer available, so here is the recent conversation for context:\n\n' +
@@ -728,6 +729,7 @@ class ClaudeAdapter extends BaseAdapter {
       lastStdoutTime: Date.now(),
       watchdogTimer: null,
       awaitingToolResult: false,
+      userStopped: false,
     };
 
     if (proc.stderr) {
@@ -803,6 +805,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 || '';
@@ -983,6 +999,12 @@ class ClaudeAdapter extends BaseAdapter {
         }
         return;
       }
+      if (existingPP.userStopped) {
+        if (!existingPP.everPostedAnything) {
+          try { await this.sendResponse(msgChannel, 'Execution stopped by user.'); } catch {}
+        }
+        return;
+      }
       // Process died mid-message — fall through to spawn a fresh one
       this._log(`Persistent process died, falling back to fresh spawn for ${msgChannel}`);
     }
@@ -1034,11 +1056,22 @@ class ClaudeAdapter extends BaseAdapter {
 
     // Spawn a persistent process and send the first message via stdin
     let effectiveContent = content;
+
+    // When starting without a session (no --resume), prepend channel
+    // history so the fresh CLI has conversation context.
+    if (!this._channelSessions[msgChannel]) {
+      try {
+        const recap = await this._buildChannelRecap(msgChannel, content);
+        if (recap) effectiveContent = `${recap}\n\n---\n\n${content}`;
+      } catch {}
+    }
+
     for (let attempt = 0; attempt < 2; attempt++) {
       if (mcpConfigFile) { try { fs.unlinkSync(mcpConfigFile); } catch {} mcpConfigFile = null; }
 
       if (attempt > 0) {
         this._killPersistentProc(msgChannel);
+        // Rebuild recap for retry without resume
         try {
           const recap = await this._buildChannelRecap(msgChannel, content);
           if (recap) effectiveContent = `${recap}\n\n---\n\n${content}`;
@@ -1065,7 +1098,13 @@ class ClaudeAdapter extends BaseAdapter {
         const result = await this._sendToPersistentProc(pp, effectiveContent);
 
         if (result.exited) {
-          this._log(`Process exited during first message (attempt ${attempt + 1})`);
+          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 {}
+            }
+            break;
+          }
           if (attempt === 0 && this._channelSessions[msgChannel]) {
             this._log(`Stale session detected, retrying without resume`);
             delete this._channelSessions[msgChannel];

package/src/adapters/cursor.js

@@ -285,6 +285,13 @@ class CursorAdapter extends BaseAdapter {
       if (jsMatch) {
         return [nodeBin, path.resolve(cmdDir, jsMatch[1])];
       }
+      // .cmd shims that forward to a native .exe — resolve to the exe and spawn
+      // it directly. Wrapping such a .cmd in `cmd.exe /c` caps the command line
+      // at cmd.exe's 8191-char limit, truncating long args (e.g. system prompts).
+      const exeMatch = cmdContent.match(/%dp0%\\([^\s"*?]+\.exe)/i);
+      if (exeMatch) {
+        return [path.resolve(cmdDir, exeMatch[1])];
+      }
     } else {
       try {
         let target = binPath;
@@ -424,7 +431,7 @@ class CursorAdapter extends BaseAdapter {
     try {
       const resolved = this._resolveToNodeCmd(cmd[0]);
       if (resolved) {
-        cmd = [resolved[0], resolved[1], ...cmd.slice(1)];
+        cmd = [...resolved, ...cmd.slice(1)];
       } else if (IS_WINDOWS && cmd[0].toLowerCase().endsWith('.cmd')) {
         cmd = ['cmd.exe', '/c', ...cmd];
       }

package/src/adapters/gemini.js

@@ -122,6 +122,13 @@ class GeminiAdapter extends BaseAdapter {
       if (jsMatch) {
         return [nodeBin, path.resolve(cmdDir, jsMatch[1])];
       }
+      // .cmd shims that forward to a native .exe — resolve to the exe and spawn
+      // it directly. Wrapping such a .cmd in `cmd.exe /c` caps the command line
+      // at cmd.exe's 8191-char limit, truncating long args (e.g. system prompts).
+      const exeMatch = cmdContent.match(/%dp0%\\([^\s"*?]+\.exe)/i);
+      if (exeMatch) {
+        return [path.resolve(cmdDir, exeMatch[1])];
+      }
     } else {
       try {
         let target = binPath;
@@ -265,7 +272,7 @@ class GeminiAdapter extends BaseAdapter {
       try {
         const resolved = this._resolveToNodeCmd(cmd[0]);
         if (resolved) {
-          cmd = [resolved[0], resolved[1], ...cmd.slice(1)];
+          cmd = [...resolved, ...cmd.slice(1)];
         } else if (IS_WINDOWS && cmd[0].toLowerCase().endsWith('.cmd')) {
           cmd = ['cmd.exe', '/c', ...cmd];
         }

package/src/adapters/opencode.js

@@ -45,6 +45,10 @@ class OpenCodeAdapter extends BaseAdapter {
     this._migrateSessionsFile();
     this._loadSessions();
 
+    // Process tracking for stop control
+    this._channelProcesses = {}; // channel → child process
+    this._stoppingChannels = new Set();
+
     this._opencodeBinary = this._findOpencodeBinary();
     if (this._opencodeBinary) {
       this._log(`Using OpenCode subprocess mode: ${this._opencodeBinary}`);
@@ -91,6 +95,32 @@ class OpenCodeAdapter extends BaseAdapter {
     } catch {}
   }
 
+  async _onControlAction(action, payload) {
+    if (action === 'stop') {
+      const channel = (payload && typeof payload === 'object') ? payload.channel : null;
+      if (channel) {
+        const proc = this._channelProcesses[channel];
+        const hadQueuedWork = !!this._channelQueues[channel]?.length;
+        if (proc) {
+          this._log(`Stopping process for channel=${channel}`);
+          this._stoppingChannels.add(channel);
+          await this._stopProcess(proc);
+          delete this._channelProcesses[channel];
+        }
+        delete this._channelQueues[channel];
+        if (proc || hadQueuedWork) {
+          try {
+            await this.sendResponse(channel, 'Execution stopped by user.');
+          } catch {}
+        }
+      } else {
+        await this._stopAllProcesses('Execution stopped by user.');
+      }
+      return;
+    }
+    await super._onControlAction(action, payload);
+  }
+
   /**
    * Write workspace skill to OpenCode's skill directory for auto-discovery.
    */
@@ -223,6 +253,11 @@ class OpenCodeAdapter extends BaseAdapter {
     try {
       const responseText = await this._runOpencode(content, msgChannel);
 
+      if (this._stoppingChannels.has(msgChannel)) {
+        this._stoppingChannels.delete(msgChannel);
+        return;
+      }
+
       if (responseText) {
         await this.sendResponse(msgChannel, responseText);
       } else {
@@ -234,6 +269,10 @@ class OpenCodeAdapter extends BaseAdapter {
         );
       }
     } catch (e) {
+      if (this._stoppingChannels.has(msgChannel)) {
+        this._stoppingChannels.delete(msgChannel);
+        return;
+      }
       this._log(`Error handling message: ${e.message}`);
       await this.sendError(msgChannel, `Error processing message: ${e.message}`);
     }
@@ -256,12 +295,12 @@ class OpenCodeAdapter extends BaseAdapter {
       // Find matching brace
       let depth = 0;
       let inStr = false;
-      let escape = false;
+      let escaped = false;
       let start = pos;
       for (let i = pos; i < raw.length; i++) {
         const ch = raw[i];
-        if (escape) { escape = false; continue; }
-        if (ch === '\\' && inStr) { escape = true; continue; }
+        if (escaped) { escaped = false; continue; }
+        if (ch === '\\' && inStr) { escaped = true; continue; }
         if (ch === '"') { inStr = !inStr; continue; }
         if (inStr) continue;
         if (ch === '{') depth++;
@@ -360,6 +399,72 @@ class OpenCodeAdapter extends BaseAdapter {
     }
   }
 
+  /**
+   * Override BaseAdapter.stop so daemon shutdown also tears down in-flight
+   * opencode subprocesses cleanly.
+   */
+  stop() {
+    this._stopAllProcesses(
+      'Task interrupted — daemon restarting. Send another message to continue.'
+    ).catch(() => {});
+    super.stop();
+  }
+
+  async _stopProcess(proc) {
+    if (!proc || proc.exitCode !== null) return;
+    try {
+      if (IS_WINDOWS) {
+        try { proc.kill('SIGINT'); } catch {}
+        const exited = await new Promise((resolve) => {
+          if (proc.exitCode !== null) {
+            resolve(true);
+            return;
+          }
+          const timeout = setTimeout(() => resolve(false), 1500);
+          proc.once('exit', () => { clearTimeout(timeout); resolve(true); });
+        });
+        if (!exited) {
+          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) => {
+          let done = false;
+          const finish = () => {
+            if (done) return;
+            done = true;
+            resolve();
+          };
+          const timeout = setTimeout(() => {
+            try { process.kill(-proc.pid, 'SIGKILL'); } catch {
+              proc.kill('SIGKILL');
+            }
+            const reapTimeout = setTimeout(finish, 1000);
+            proc.once('exit', () => { clearTimeout(reapTimeout); finish(); });
+          }, 1500);
+          proc.once('exit', () => { clearTimeout(timeout); finish(); });
+        });
+      }
+    } catch {}
+  }
+
+  async _stopAllProcesses(completionMessage = 'Execution stopped.') {
+    const entries = Object.entries(this._channelProcesses);
+    if (!entries.length) return;
+    this._log(`Stopping ${entries.length} running process(es)...`);
+    for (const [channel, proc] of entries) {
+      this._stoppingChannels.add(channel);
+      await this._stopProcess(proc);
+      delete this._channelProcesses[channel];
+      delete this._channelQueues[channel];
+      try {
+        await this.sendResponse(channel, completionMessage);
+      } catch {}
+    }
+  }
+
   // ------------------------------------------------------------------
   // Subprocess execution
   // ------------------------------------------------------------------
@@ -444,16 +549,26 @@ class OpenCodeAdapter extends BaseAdapter {
         env: spawnEnv,
         cwd: this.agentHome,
         timeout: TIMEOUT_MS,
+        detached: !IS_WINDOWS,
         // Never let a console window appear. Besides being ugly, an attached
         // console makes opencode start its interactive TUI and hang instead of
         // running headless — the root cause of "stuck on thinking…" on Windows.
         windowsHide: true,
       });
 
+      this._channelProcesses[msgChannel] = proc;
+
       let stdout = '';
       let stderr = '';
       let settled = false;
-      const finish = (fn, arg) => { if (!settled) { settled = true; fn(arg); } };
+      const finish = (fn, arg) => {
+        if (settled) return;
+        settled = true;
+        if (this._channelProcesses[msgChannel] === proc) {
+          delete this._channelProcesses[msgChannel];
+        }
+        fn(arg);
+      };
 
       if (proc.stdout) proc.stdout.on('data', (d) => { stdout += d; });
       if (proc.stderr) proc.stderr.on('data', (d) => { stderr += d; });
@@ -475,6 +590,11 @@ class OpenCodeAdapter extends BaseAdapter {
       // when the spawn timeout kills the child, code is null and signal is the
       // signal name — report that as a timeout rather than "exited with code null".
       proc.on('close', (code, signal) => {
+        if (this._stoppingChannels.has(msgChannel)) {
+          this._stoppingChannels.delete(msgChannel);
+          return finish(resolve, '');
+        }
+
         stdout = stdout.trim();
         stderr = stderr.trim();
 

package/src/cli.js

@@ -41,6 +41,9 @@ function parseArgs(argv) {
 function getConnector(flags) {
   const opts = {};
   if (flags.config) opts.configDir = flags.config;
+  if (flags.endpoint || process.env.OPENAGENTS_ENDPOINT) {
+    opts.workspaceEndpoint = flags.endpoint || process.env.OPENAGENTS_ENDPOINT;
+  }
   return new AgentConnector(opts);
 }
 
@@ -358,6 +361,8 @@ async function cmdConnect(connector, flags, positional) {
     if (pid) {
       connector.sendDaemonCommand(`restart:${name}`);
       print('Daemon notified');
+    } else {
+      print('Daemon is not running. Run `agn up` to bring this agent online.');
     }
   } catch (e) {
     print(`Error: ${e.message}`);

package/src/daemon.js

@@ -151,6 +151,14 @@ class Daemon {
       if (!this._adapters || !this._adapters[agentName]) break;
       await new Promise(r => setTimeout(r, 500));
     }
+    // Force-clear the adapter slot if it's still hanging. Without this,
+    // a hung adapter.run() promise prevents the slot from ever being
+    // released, and subsequent start/restart commands see "already running".
+    if (this._adapters && this._adapters[agentName]) {
+      this._log(`WARNING: ${agentName} adapter did not exit after stop — force-releasing slot`);
+      try { this._adapters[agentName].stop(); } catch {}
+      delete this._adapters[agentName];
+    }
     this._writeStatus();
   }
 
@@ -319,7 +327,17 @@ class Daemon {
    * Read daemon PID, returning null if not running.
    */
   static readDaemonPid(configDir) {
-    return Daemon._readPid(path.join(configDir, 'daemon.pid'));
+    const pidFile = path.join(configDir, 'daemon.pid');
+    const statusFile = path.join(configDir, 'daemon.status.json');
+    const pid = Daemon._readPid(pidFile);
+    if (!pid) return null;
+
+    if (!Daemon._isAlive(pid)) {
+      Daemon._cleanupStaleDaemonFiles(pidFile, statusFile);
+      return null;
+    }
+
+    return pid;
   }
 
   // ---------------------------------------------------------------------------
@@ -865,6 +883,17 @@ class Daemon {
     }
   }
 
+  static _cleanupStaleDaemonFiles(pidFile, statusFile) {
+    Daemon._unlinkIfExists(pidFile);
+    Daemon._unlinkIfExists(statusFile);
+  }
+
+  static _unlinkIfExists(filePath) {
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+    }
+  }
+
   static _isAlive(pid) {
     try {
       process.kill(pid, 0);

package/src/installer.js

@@ -132,7 +132,12 @@ class Installer {
       : null;
     if (verifyCmd) {
       try {
-        require('child_process').execSync(verifyCmd, { stdio: 'ignore', timeout: 5000 });
+        // Use the enhanced PATH so a freshly-installed CLI living in a dir the
+        // installer added (e.g. %LOCALAPPDATA%\cursor-agent) is found — otherwise
+        // `cursor-agent --version` exits "not recognized" and verify wrongly fails.
+        require('child_process').execSync(verifyCmd, {
+          stdio: 'ignore', timeout: 5000, env: getEnhancedEnv(), windowsHide: true,
+        });
         return true;
       } catch { return false; }
     }

package/src/update-check.js

@@ -140,9 +140,14 @@ function runUpdate(opts = {}) {
   const spawn = opts.spawn || spawnSync;
   const npmBin = opts.npmBin || findNpmBin({ platform });
   const prefix = opts.prefix !== undefined ? opts.prefix : detectInstallPrefix();
-  const args = ['install', '--no-save', `${PKG_NAME}@latest`];
+  // Use a GLOBAL install (-g). A LOCAL install (`npm install <pkg> --prefix
+  // <dir>`) treats <dir> as a project root and prunes every node_modules entry
+  // not reachable from its package.json. When the prefix is the portable node
+  // dir, that deletes node's own bundled npm/corepack (and other agent runtimes),
+  // breaking every subsequent `agn` command. A global install only adds/updates
+  // the named package into <prefix>/node_modules and never prunes its siblings.
+  const args = ['install', '-g', `${PKG_NAME}@latest`];
   if (prefix) args.push('--prefix', prefix);
-  else args.push('-g');
 
   // On Windows, npm.cmd is a batch file and must be invoked through cmd.exe.
   // Passing the args via cmd.exe with shell:false lets Node quote paths that