@openagents-org/agent-launcher 0.2.184 → 0.2.185

package/src/adapters/kimi.js

@@ -199,24 +199,6 @@ class KimiAdapter extends LlmDirectAdapter {
   // ------------------------------------------------------------------
 
   async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      const channel = (payload && typeof payload === 'object') ? payload.channel : null;
-      if (channel && this._channelProcesses[channel]) {
-        this._stoppingChannels.add(channel);
-        await this._stopProcess(this._channelProcesses[channel]);
-        delete this._channelProcesses[channel];
-        delete this._channelQueues[channel];
-        try { await this.sendResponse(channel, 'Execution stopped by user.'); } catch {}
-        return;
-      }
-      if (Object.keys(this._channelProcesses).length) {
-        await this._stopAllProcesses('Execution stopped by user.');
-        return;
-      }
-      // No CLI runs in flight — fall through to the direct-API stop.
-      await super._onControlAction(action, payload);
-      return;
-    }
     if (action === 'restart') {
       const channel = (payload && typeof payload === 'object') ? payload.channel : null;
       if (channel) {
@@ -685,6 +667,8 @@ class KimiAdapter extends LlmDirectAdapter {
    * `timedOutMs` is non-zero when the idle watchdog stopped the run.
    */
   _runKimi(channel, kimiBin, args, workingDir) {
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(channel)) return Promise.resolve({ userStopped: true });
     const { env: cleanEnv } = buildKimiEnv(this.agentEnv || process.env);
     const [cmd, ...spawnArgs] = this._spawnableCmd(kimiBin, args);
     // Before the spawn, so the session this run creates shows up as new.

package/src/adapters/llm-direct.js

@@ -62,13 +62,21 @@ class LlmDirectAdapter extends BaseAdapter {
     this._activeRequests.clear();
   }
 
-  async _onControlAction(action, _payload) {
-    if (action === 'stop') {
-      for (const req of this._activeRequests) {
-        try { req.destroy(new Error('LLM API request stopped')); } catch {}
-      }
-      this._activeRequests.clear();
+  /**
+   * A stop ends this channel's open completion requests, and only those —
+   * the same agent may be answering in another thread. Subclasses that also
+   * run child processes (kimi) get those stopped by super.
+   */
+  async _stopChannelWork(channel) {
+    let aborted = 0;
+    for (const req of this._activeRequests) {
+      if (req._oaChannel !== channel) continue;
+      try { req.destroy(new Error('LLM API request stopped')); } catch {}
+      this._activeRequests.delete(req);
+      aborted++;
     }
+    const processes = await super._stopChannelWork(channel);
+    return aborted && processes === 'idle' ? 'stopped' : processes;
   }
 
   /** The model this runner actually calls with — see `_model` above. */
@@ -114,6 +122,8 @@ class LlmDirectAdapter extends BaseAdapter {
         return;
       }
 
+      // Stopped while this turn was being prepared: start nothing (no tokens).
+      if (this._stoppedBeforeStart(msgChannel)) return;
       const responseText = await this._callCompletionApi(content, msgChannel);
 
       if (responseText) {
@@ -205,6 +215,7 @@ class LlmDirectAdapter extends BaseAdapter {
         });
       });
 
+      req._oaChannel = channel;
       this._activeRequests.add(req);
       req.on('error', (err) => {
         this._activeRequests.delete(req);

package/src/adapters/mini.js

@@ -297,22 +297,9 @@ class MiniSweAgentAdapter extends BaseAdapter {
   }
 
   // ------------------------------------------------------------------
-  // Control actions (stop)
+  // Process teardown (BaseAdapter._stopChannelWork calls _stopProcess)
   // ------------------------------------------------------------------
 
-  async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      for (const [channel, proc] of Object.entries(this._channelProcesses)) {
-        this._stoppingChannels.add(channel);
-        await this._stopProcess(proc);
-        delete this._channelProcesses[channel];
-        try { await this.sendStatus(channel, 'Execution stopped by user'); } catch {}
-      }
-      return;
-    }
-    await super._onControlAction(action, payload);
-  }
-
   async _stopProcess(proc) {
     if (!proc || proc.exitCode !== null) return;
     try {
@@ -460,6 +447,8 @@ class MiniSweAgentAdapter extends BaseAdapter {
   }
 
   _spawnMini(cmd, msgChannel) {
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(msgChannel)) return Promise.resolve({ text: '', error: null });
     return new Promise((resolve, reject) => {
       const env = this._buildSubprocessEnv();
 

package/src/adapters/nanoclaw.js

@@ -248,6 +248,12 @@ class NanoClawAdapter extends BaseAdapter {
     await this._autoTitleChannel(channel, content);
     await this.sendStatus(channel, 'thinking...');
 
+    // Stopped while this turn was being prepared: inject nothing (no tokens).
+    if (this._stoppedBeforeStart(channel)) {
+      if (this._activeTurn.get(channel) === turnId) this._activeTurn.delete(channel);
+      return;
+    }
+
     // Inject and await the turn.
     this._injectedIds.add(msgId);
     let injected = false;
@@ -278,14 +284,25 @@ class NanoClawAdapter extends BaseAdapter {
   // never kills the Agent Group, the NanoClaw host, or any shared container.
   // ------------------------------------------------------------------
 
-  async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      const ch = payload && (payload.channel || payload.sessionId || payload.session);
-      if (ch) this._detachChannel(String(ch));
-      else for (const c of this._activeChannels()) this._detachChannel(c);
-      return;
-    }
-    await super._onControlAction(action, payload);
+  // BaseAdapter._handleUserStop drives these. A named channel is always
+  // detached (its epoch moves even if nothing was in flight), matching what
+  // the stop meant here before it moved into the base class.
+  async _stopChannelWork(channel) {
+    const wasActive = this._activeTurn.has(channel)
+      || this._pending.has(proto.platformIdFor(this.workspaceId, channel));
+    this._detachChannel(channel);
+    return wasActive ? 'stopped' : 'idle';
+  }
+
+  _channelsWithWork() {
+    return [...new Set([...super._channelsWithWork(), ...this._activeChannels()])];
+  }
+
+  /** The container task is not cancelled, only let go of — say so. */
+  _stopNoticeText(outcome) {
+    if (outcome === 'failed') return super._stopNoticeText(outcome);
+    return 'Stopped \u2014 replies from the previous task are dropped; a new message starts a fresh '
+      + 'NanoClaw session. The previous task may keep running in the background.';
   }
 
   _activeChannels() {
@@ -329,11 +346,6 @@ class NanoClawAdapter extends BaseAdapter {
     const state = this._pending.get(platformId);
     if (state && state.settle) state.settle({ detached: true });
     if (this._bridge) this._bridge.sendCancel(platformId, null); // best-effort notify
-    this.sendStatus(
-      channel,
-      'Stopped — replies from the previous task are dropped; a new message starts a fresh NanoClaw session. The previous task may keep running in the background.',
-      { nanoclaw_state: 'detached' },
-    ).catch(() => {});
   }
 
   /** A queued NanoClaw reply was dropped (overflow / expiry / corrupt) — surface it. */

package/src/adapters/openclaw.js

@@ -41,6 +41,9 @@ class OpenClawAdapter extends BaseAdapter {
     super(opts);
     this.openclawAgentId = opts.openclawAgentId || 'main';
     this.disabledModules = opts.disabledModules || new Set();
+    // channel → the `openclaw agent` run in flight, so a stop can end it
+    // instead of letting it spend tokens until it finishes on its own.
+    this._channelProcesses = {};
 
     // Find the openclaw binary — always use CLI/gateway mode for full tool support
     this._openclawBinary = this._findOpenclawBinary();
@@ -250,6 +253,7 @@ class OpenClawAdapter extends BaseAdapter {
 
     try {
       const responseText = await this._runCliAgent(content, msgChannel);
+      if (this._stoppingChannels.has(msgChannel)) return;
 
       if (responseText) {
         await this.sendResponse(msgChannel, responseText);
@@ -268,6 +272,11 @@ class OpenClawAdapter extends BaseAdapter {
 
   _runCliAgent(userMessage, channel) {
     return new Promise((resolve, reject) => {
+      // Stopped while this turn was being prepared: start nothing (no tokens).
+      if (this._stoppedBeforeStart(channel)) {
+        resolve('');
+        return;
+      }
       // Re-check binary if not found at construction time (installed after daemon started)
       if (!this._openclawBinary) {
         this._openclawBinary = this._findOpenclawBinary();
@@ -383,8 +392,14 @@ class OpenClawAdapter extends BaseAdapter {
         env: spawnEnv,
         cwd: this.workingDir || process.env.HOME || '/',
         timeout: 600000,
+        // Its own process group, so a stop reaches the tools it started too.
+        detached: !IS_WINDOWS,
         windowsHide: true,
       });
+      this._channelProcesses[channel] = proc;
+      const unregister = () => {
+        if (this._channelProcesses[channel] === proc) delete this._channelProcesses[channel];
+      };
       if (proc.stdout) proc.stdout.on('data', (d) => { output += d; });
 
       // Poll stderr file every 500ms for tool events
@@ -423,6 +438,7 @@ class OpenClawAdapter extends BaseAdapter {
       }, 600000);
 
       proc.on('error', (err) => {
+        unregister();
         if (settled) return;
         settled = true;
         clearInterval(pollInterval);
@@ -432,6 +448,7 @@ class OpenClawAdapter extends BaseAdapter {
         reject(err);
       });
       proc.on('exit', (code) => {
+        unregister();
         if (settled) return;
         settled = true;
         clearInterval(pollInterval);
@@ -457,6 +474,11 @@ class OpenClawAdapter extends BaseAdapter {
         const hasPayloads = allOutput.includes('"payloads"');
         this._log(`CLI parse: hasPayloads=${hasPayloads}, total=${allOutput.length}b`);
 
+        // Killed by a user stop: the stop has been announced, nothing to report.
+        if (this._stoppingChannels.has(channel)) {
+          resolve('');
+          return;
+        }
         if (code !== 0) {
           reject(new Error(`CLI exited ${code}: ${allOutput.slice(-300)}`));
           return;
@@ -466,6 +488,25 @@ class OpenClawAdapter extends BaseAdapter {
     });
   }
 
+  /** End a run and everything it started (BaseAdapter._stopChannelWork calls this). */
+  async _stopProcess(proc) {
+    if (!proc || proc.exitCode !== null) return;
+    try {
+      if (IS_WINDOWS) {
+        try { execSync(`taskkill /F /T /PID ${proc.pid}`, { timeout: 5000 }); } catch {}
+        return;
+      }
+      try { process.kill(-proc.pid, 'SIGTERM'); } catch { proc.kill('SIGTERM'); }
+      await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          try { process.kill(-proc.pid, 'SIGKILL'); } catch { proc.kill('SIGKILL'); }
+          resolve();
+        }, 5000);
+        proc.on('exit', () => { clearTimeout(timeout); resolve(); });
+      });
+    } catch {}
+  }
+
   _parseCliOutput(output, resolve) {
     const text = output.trim();
     if (!text) { resolve(''); return; }

package/src/adapters/opencode.js

@@ -237,32 +237,6 @@ class OpenCodeAdapter extends BaseAdapter {
     return path.join(this.agentHome, `sessions-${slug}.json`);
   }
 
-  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.
    */
@@ -861,6 +835,9 @@ class OpenCodeAdapter extends BaseAdapter {
       spawnBinary = process.env.COMSPEC || 'cmd.exe';
     }
 
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(msgChannel)) return Promise.resolve('');
+
     return new Promise((resolve, reject) => {
       const proc = spawn(spawnBinary, spawnArgs, {
         stdio: ['pipe', 'pipe', 'pipe'],
@@ -1177,6 +1154,8 @@ class OpenCodeAdapter extends BaseAdapter {
    * normal reply. Carries `error_category` in metadata so the UI can route it.
    */
   async _sendClassifiedError(channel, category, detail) {
+    // A run the user stopped reads as "stopped mid-task"; it is not an error.
+    if (this._isMuted(channel)) return;
     const messages = this._failureMessages();
     const base = messages[category] || messages.unknown_error;
     const safe = detail ? OpenCodeAdapter._redact(detail).trim() : '';

package/src/adapters/openworker.js

@@ -536,28 +536,26 @@ class OpenWorkerAdapter extends BaseAdapter {
   }
 
   // ------------------------------------------------------------------
-  // Control actions (stop / restart)
+  // Stop / shutdown
   // ------------------------------------------------------------------
 
-  async _onControlAction(action, payload) {
-    if (action === 'stop') {
-      const channel = (payload && payload.channel) || null;
-      if (channel) {
-        await this._stopChannel(channel, 'Execution stopped.');
-        return;
-      }
-      await this._stopAllChannels();
-      return;
-    }
-    return super._onControlAction(action, payload);
-  }
-
   stop() {
     super.stop();
     this._serverStopped = true;
     void this._stopAllChannels('Agent stopped.').finally(() => this._stopServer());
   }
 
+  /** A turn here is a socket to the engine, not a child process. */
+  async _stopChannelWork(channel) {
+    if (!this._channelSockets[channel]) return super._stopChannelWork(channel);
+    await this._stopChannel(channel, null);
+    return 'stopped';
+  }
+
+  _channelsWithWork() {
+    return [...new Set([...super._channelsWithWork(), ...Object.keys(this._channelSockets)])];
+  }
+
   async _stopChannel(channel, message) {
     const socket = this._channelSockets[channel];
     if (!socket) return;
@@ -637,6 +635,10 @@ class OpenWorkerAdapter extends BaseAdapter {
    * @returns {Promise<object>} { texts, error, interrupted, userStopped, sent }
    */
   _runTurn(channel, server, sessionId, workingDir, text, { planMode, model }) {
+    // Stopped while this turn was being prepared: start nothing (no tokens).
+    if (this._stoppedBeforeStart(channel)) {
+      return Promise.resolve({ texts: [], error: null, interrupted: false, userStopped: true, sent: false });
+    }
     return new Promise((resolve) => {
       const url = sessionUrl({
         port: server.port,
@@ -686,6 +688,11 @@ class OpenWorkerAdapter extends BaseAdapter {
 
       const sendTurn = () => {
         if (sentMessage) return;
+        // The handshake takes a moment; a stop inside it still sends nothing.
+        if (this._stoppedBeforeStart(channel)) {
+          finish({});
+          return;
+        }
         sentMessage = true;
         // Anything observed before this point belongs to the turn we cleared out
         // of the way (see the `ready.running` branch), not to ours — carrying it

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 };