@openagents-org/agent-launcher 0.2.184 → 0.2.186

package/src/adapters/pi.js

@@ -147,9 +147,6 @@ class PiAdapter extends BaseAdapter {
     // channel → child process (BaseAdapter/stop paths read this)
     this._channelProcesses = {};
     this._stoppingChannels = new Set();
-    // Dedup for "Execution stopped by user." — the control handler and the
-    // in-flight message handler both race to announce it (see claude.js).
-    this._stopNoticeSent = new Set();
 
     this._sessionsFile = path.join(
       os.homedir(), '.openagents', 'sessions',
@@ -524,24 +521,6 @@ class PiAdapter 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 (this._channelProcesses[channel]) {
-          this._log(`Stopping Pi for channel=${channel}`);
-          this._stoppingChannels.add(channel);
-          await this._abortChannel(channel);
-          delete this._channelQueues[channel];
-          await this._postStopNotice(channel);
-        }
-      } else {
-        for (const pp of Object.values(this._persistentProcs)) pp.userStopped = true;
-        await this._stopAllProcesses('Execution stopped by user.');
-      }
-      return;
-    }
     if (action === 'restart') {
       const channel = (payload && typeof payload === 'object') ? payload.channel : null;
       if (channel) {
@@ -594,11 +573,20 @@ class PiAdapter extends BaseAdapter {
     }
   }
 
-  /** Post "Execution stopped by user." at most once per stop, per 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 {}
+  /**
+   * Stop ONE channel's Pi turn (BaseAdapter._handleUserStop drives this).
+   * `userStopped` goes on first so the turn that is winding down reports a
+   * stop rather than a failure.
+   */
+  async _stopChannelWork(channel) {
+    const pp = this._persistentProcs[channel];
+    if (pp) pp.userStopped = true;
+    // Abort goes over the RPC channel of the persistent record; a bare child
+    // with no record is simply killed.
+    if (!pp || !this._channelProcesses[channel]) return super._stopChannelWork(channel);
+    this._log(`Stopping Pi for channel=${channel}`);
+    await this._abortChannel(channel);
+    return 'stopped';
   }
 
   /**
@@ -1346,7 +1334,6 @@ class PiAdapter extends BaseAdapter {
     const channel = msg.sessionId || this.channelName || 'general';
 
     this._stoppingChannels.delete(channel);
-    this._stopNoticeSent.delete(channel);
 
     if (!content && !attachments.length) return;
 
@@ -1400,6 +1387,9 @@ class PiAdapter extends BaseAdapter {
       browserEnabled,
     });
 
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(channel)) return;
+
     let pp;
     try {
       pp = await this._ensureProc(channel, workingDir, systemPrompt);
@@ -1408,6 +1398,9 @@ class PiAdapter extends BaseAdapter {
       return;
     }
 
+    // Starting the process takes a moment; the prompt is what costs tokens.
+    if (this._stoppedBeforeStart(channel)) return;
+
     // Fresh per-turn accounting.
     pp.msgChannel = channel;
     pp.turnTexts = [];
@@ -1453,7 +1446,7 @@ class PiAdapter extends BaseAdapter {
     pp.turnInFlight = false;
 
     if (pp.userStopped || this._stoppingChannels.has(channel)) {
-      if (!pp.everPosted) await this._postStopNotice(channel);
+      await this._finishUserStop(channel);
       pp.userStopped = false;
       return;
     }
@@ -1470,7 +1463,7 @@ class PiAdapter extends BaseAdapter {
   async _reportTurnFailure(pp, channel, error) {
     const raw = (error && error.message) || String(error);
     if (error instanceof PiCancelledError && (pp.userStopped || this._stoppingChannels.has(channel))) {
-      await this._postStopNotice(channel);
+      await this._finishUserStop(channel);
       return;
     }
     const { kind, userMessage } = classifyPiError(raw);

package/src/daemon.js

@@ -23,6 +23,27 @@ function maskApiKey(key) {
   return key.slice(0, 4) + '...' + key.slice(-4);
 }
 
+/**
+ * Top-level filesystem locations the workspace folder picker can jump to.
+ * Windows has one root per mounted drive; POSIX systems have a single root.
+ * Keeping this as a small pure helper makes the Windows behaviour testable on
+ * every CI platform.
+ */
+function filesystemRoots(platform = os.platform(), exists = fs.existsSync) {
+  if (platform !== 'win32') return ['/'];
+
+  const roots = [];
+  for (let code = 'A'.charCodeAt(0); code <= 'Z'.charCodeAt(0); code++) {
+    const root = `${String.fromCharCode(code)}:\\`;
+    try {
+      if (exists(root)) roots.push(root);
+    } catch {
+      // A disconnected or unreadable mapped drive should not break heartbeat.
+    }
+  }
+  return roots;
+}
+
 /**
  * Agent process lifecycle manager.
  *
@@ -327,8 +348,9 @@ class Daemon {
   }
 
   /**
-   * Filesystem hint for the working-directory picker: home + its immediate
-   * (non-hidden) subfolders, so the workspace can show real folders instantly.
+   * Filesystem hint for the working-directory picker: home, its immediate
+   * (non-hidden) subfolders, and the device's filesystem roots. Roots let a
+   * Windows user switch drives instead of being trapped on the home drive.
    */
   _buildFs() {
     try {
@@ -338,7 +360,7 @@ class Daemon {
         .map((d) => d.name)
         .sort((a, b) => a.localeCompare(b))
         .slice(0, 100);
-      return { home, dirs };
+      return { home, dirs, roots: filesystemRoots() };
     } catch {
       return {};
     }
@@ -374,6 +396,31 @@ class Daemon {
     if (nativeVar) await this._runAgn(['env', type, '--set', `${nativeVar}=${val}`]);
   }
 
+  /**
+   * A node command targets one agent. The launcher may already have saved an
+   * instance-level model/key/URL, which wins over the type env written above.
+   * Mirror the command onto that instance so the running adapter and the
+   * launcher's "This Computer" row both see the requested settings.
+   */
+  _saveNodeAgentEnv(name, type, args) {
+    const changes = {};
+    if (args.apiKey && !args.useDeviceCredentials) changes.LLM_API_KEY = args.apiKey;
+    if (args.baseUrl !== undefined) changes.LLM_BASE_URL = args.baseUrl;
+    if (args.model !== undefined) {
+      const existing = this.config.getAgent(name);
+      if (!existing) throw new Error(`Agent '${name}' not found after create`);
+      // Old instance-level native model keys can outrank LLM_MODEL in the
+      // launcher's display and in CLIs without a resolve_env model rule.
+      for (const key of Object.keys(existing.env || {})) {
+        if (key === 'MODEL' || key.endsWith('_MODEL')) changes[key] = '';
+      }
+      changes.LLM_MODEL = String(args.model || '');
+      const nativeVar = { claude: 'ANTHROPIC_MODEL', gemini: 'GEMINI_MODEL' }[type] || this._nativeModelVar(type);
+      if (nativeVar) changes[nativeVar] = String(args.model || '');
+    }
+    if (Object.keys(changes).length) this.config.updateAgentEnv(name, changes);
+  }
+
   /**
    * The agent's own model setting, for a type whose registry declares one and
    * does not map LLM_MODEL onto anything itself (CodeArts reads CODEARTS_MODEL
@@ -477,6 +524,7 @@ async _runNodeCommand(n, cmd) {
         if (args.model) await this._setModelEnv(type, args.model);
         if (args.baseUrl) await this._runAgn(['env', type, '--set', `LLM_BASE_URL=${args.baseUrl}`]);
         await this._applyConfigMap(type, args.config);
+        this._saveNodeAgentEnv(name, type, args);
         // Attach to this node's workspace BY SLUG: the daemon already knows
         // which workspace this command came from, so there is no token to
         // pass and no /v1/token/resolve round-trip to fail (the outage class
@@ -519,6 +567,7 @@ async _runNodeCommand(n, cmd) {
           await this._runAgn(['remove', name]);
           const rc = await this._runAgn(['create', name, '--type', type, '--install', '--path', newDir]);
           if (rc.code !== 0) throw new Error(rc.stderr || rc.stdout || 'recreate failed');
+          this._saveNodeAgentEnv(name, type, args);
           const rc2 = await this._runAgn([
             'connect', name, '--workspace', n.workspace_slug || n.workspace_id,
           ]);
@@ -528,6 +577,7 @@ async _runNodeCommand(n, cmd) {
           // through daemon.cmd, and writeCommand() OVERWRITES that file — the
           // start could clobber the unread stop (agent keeps the stale env) or
           // interleave with the poll so the agent stops and never restarts.
+          this._saveNodeAgentEnv(name, type, args);
           await this.restartAgent(name);
         }
         ok = true;
@@ -1722,4 +1772,4 @@ async _runNodeCommand(n, cmd) {
   }
 }
 
-module.exports = { Daemon };
+module.exports = { Daemon, filesystemRoots };

package/src/wsl.js

@@ -27,9 +27,10 @@
  * The mirror direction needs no marker: a path ending in .exe/.cmd/.bat while
  * we are running inside a distro is unambiguously a Windows binary.
  *
- * Cost: resolution never spawns wsl.exe per binary. One probe (5 min TTL) reads
- * the distro's login PATH, and every later lookup is a filesystem check through
- * the \\wsl.localhost UNC mount.
+ * Background resolution checks whether the default distro is already running
+ * before probing its login PATH or UNC mount. A stopped distro is left stopped;
+ * after the user starts it, the next scan can detect its CLIs. One PATH probe
+ * (5 min TTL) then serves later lookups through the \\wsl.localhost UNC mount.
  *
  * Inside the desktop app's main process none of that may block: starting
  * wsl.exe can mean booting the WSL VM, and the first touch of the UNC mount
@@ -53,6 +54,9 @@ const CACHE_TTL_MS = 30 * 1000;
  * the VM (and, in the desktop app, the window) busy for nothing.
  */
 const MACHINE_TTL_MS = 5 * 60 * 1000;
+// A stopped distro must never be woken by background detection. Keep this
+// short so a distro the user starts becomes visible on the next scan.
+const RUNNING_TTL_MS = 2000;
 
 function _fresh(cache, ttl) {
   return !!cache.at && Date.now() - cache.at < ttl;
@@ -126,6 +130,8 @@ function isRunningInWsl() {
 
 let distrosCache = { value: null, at: 0 };
 let distrosRefresh = null;
+let runningDistrosCache = { value: null, at: 0 };
+let runningDistrosRefresh = null;
 
 function _parseDistros(buf) {
   return Buffer.from(buf)
@@ -203,6 +209,49 @@ function defaultDistro() {
   return wslDistros()[0] || null;
 }
 
+function _refreshRunningDistros() {
+  if (_fresh(runningDistrosCache, RUNNING_TTL_MS)) return Promise.resolve();
+  if (!runningDistrosRefresh) {
+    runningDistrosRefresh = _execFileOut('wsl.exe', ['-l', '--running', '-q'], {
+      encoding: 'buffer', maxBuffer: 1024 * 1024,
+    })
+      .then((out) => { runningDistrosCache = { value: out ? _parseDistros(out) : [], at: Date.now() }; })
+      .finally(() => { runningDistrosRefresh = null; });
+  }
+  return runningDistrosRefresh;
+}
+
+/** Query WSL's management state without executing a command inside a distro. */
+function _defaultDistroRunning() {
+  const distro = defaultDistro();
+  if (!distro) return false;
+  if (!_fresh(runningDistrosCache, RUNNING_TTL_MS)) {
+    if (!canBlock()) {
+      void _refreshRunningDistros();
+    } else {
+      let names = [];
+      try {
+        names = _parseDistros(execFileSync('wsl.exe', ['-l', '--running', '-q'], {
+          timeout: PROBE_TIMEOUT_MS,
+          windowsHide: true,
+          stdio: ['ignore', 'pipe', 'ignore'],
+          maxBuffer: 1024 * 1024,
+        }));
+      } catch { /* WSL unavailable: do not wake it */ }
+      runningDistrosCache = { value: names, at: Date.now() };
+    }
+  }
+  return (runningDistrosCache.value || []).includes(distro);
+}
+
+async function _defaultDistroRunningAsync() {
+  await _refreshDistros();
+  const distro = (distrosCache.value || [])[0];
+  if (!distro) return false;
+  await _refreshRunningDistros();
+  return (runningDistrosCache.value || []).includes(distro);
+}
+
 // ---------------------------------------------------------------------------
 // Windows side: reaching into the distro's filesystem without starting one
 // ---------------------------------------------------------------------------
@@ -216,7 +265,7 @@ function _refreshUncRoot() {
   if (_fresh(uncRootCache, MACHINE_TTL_MS)) return Promise.resolve();
   if (!uncRootRefresh) {
     uncRootRefresh = (async () => {
-      await _refreshDistros();
+      if (!(await _defaultDistroRunningAsync())) return;
       const distro = (distrosCache.value || [])[0];
       if (!distro) return;
       let root = null;
@@ -242,6 +291,7 @@ function _refreshUncRoot() {
  * WSL2 serves \\wsl.localhost\<distro>; WSL1 and older builds only \\wsl$\.
  */
 function _uncRoot() {
+  if (!_defaultDistroRunning()) return null;
   if (_fresh(uncRootCache, MACHINE_TTL_MS)) {
     return uncRootCache.value;
   }
@@ -334,8 +384,7 @@ function _refreshShellProbe() {
   if (_fresh(shellProbeCache, MACHINE_TTL_MS)) return Promise.resolve();
   if (!shellProbeRefresh) {
     shellProbeRefresh = (async () => {
-      await _refreshDistros();
-      if (!(distrosCache.value || []).length) return;
+      if (!(await _defaultDistroRunningAsync())) return;
       let out = null;
       for (const argv of SHELL_PROBE_ARGVS) {
         const raw = await _execFileOut('wsl.exe', argv, { encoding: 'utf-8', maxBuffer: 4 * 1024 * 1024 });
@@ -365,6 +414,7 @@ function _refreshShellProbe() {
  */
 function _shellProbe() {
   const empty = _emptyShellProbe();
+  if (!_defaultDistroRunning()) return empty;
   if (_fresh(shellProbeCache, MACHINE_TTL_MS)) {
     return shellProbeCache.value || empty;
   }
@@ -428,7 +478,7 @@ const wslBinaryRefresh = new Map();
 function _refreshWslBinary(key, list) {
   if (wslBinaryRefresh.has(key)) return wslBinaryRefresh.get(key);
   const job = (async () => {
-    await _refreshDistros();
+    if (!(await _defaultDistroRunningAsync())) return;
     let value = null;
     if ((distrosCache.value || []).length) {
       await Promise.all([_refreshUncRoot(), _refreshShellProbe()]);
@@ -465,13 +515,14 @@ function _refreshWslBinary(key, list) {
  * Returns the path as the DISTRO sees it, behind the `wsl:` marker
  * (`wsl:/home/u/.local/bin/claude`) — the inner path is what `wsl.exe -e` must
  * be handed. Existence is proved through the UNC mount, so a machine with WSL
- * installed but no distro pays nothing beyond the single cached distro listing.
+ * installed but no running default distro pays only for WSL management queries.
  *
  * @param {string|string[]} names binary name(s), e.g. 'claude' or ['cursor-agent','agent']
  * @returns {string|null} marked in-distro path
  */
 function resolveWslBinary(names) {
   if (!IS_WINDOWS) return null;
+  if (!_defaultDistroRunning()) return null;
   const list = (Array.isArray(names) ? names : [names]).filter(Boolean);
   if (!list.length) return null;
   const key = list.join('\0');
@@ -520,6 +571,7 @@ function clearWslBinaryCache() {
 /** Full reset, including the per-process probes. For tests and rare rescans. */
 function clearWslCache() {
   distrosCache = { value: null, at: 0 };
+  runningDistrosCache = { value: null, at: 0 };
   uncRootCache = { value: null, at: 0 };
   shellProbeCache = { value: null, at: 0 };
   wslBinaryCache.clear();