@openagents-org/agent-launcher 0.2.163 → 0.2.165

package/package.json

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

package/src/cli.js

@@ -1,5 +1,9 @@
 'use strict';
 
+// Before ./index so the daemon and every `agn` subprocess inherit the same
+// no-stray-console-window default on Windows. See win-console.js.
+require('./win-console').installWindowsHideDefault();
+
 const { AgentConnector, Daemon } = require('./index');
 const { hasCredentialMetadata, formatAuthGuidance } = require('./auth-guidance');
 

package/src/daemon.js

@@ -136,6 +136,18 @@ class Daemon {
    * so the (synchronous, execSync-heavy) version/login probes never block the
    * daemon's event loop. Result is reported to the workspace on the heartbeat.
    */
+  /**
+   * Persist an agent's model. Sets the generic LLM_MODEL (used by LLM-direct
+   * adapters) plus the env var the agent's own CLI reads, so a model picked in
+   * the workspace actually takes effect (e.g. Claude reads ANTHROPIC_MODEL).
+   */
+  async _setModelEnv(type, model) {
+    const val = String(model || '');
+    const nativeVar = { claude: 'ANTHROPIC_MODEL', gemini: 'GEMINI_MODEL' }[type];
+    await this._runAgn(['env', type, '--set', `LLM_MODEL=${val}`]);
+    if (nativeVar) await this._runAgn(['env', type, '--set', `${nativeVar}=${val}`]);
+  }
+
   async _refreshRuntimes() {
     try {
       const r = await this._runAgn(['runtimes', '--json']);
@@ -174,7 +186,7 @@ class Daemon {
         // Optional credentials for API-key agents (generic → provider mapping
         // happens in env resolution).
         if (args.apiKey) await this._runAgn(['env', type, '--set', `LLM_API_KEY=${args.apiKey}`]);
-        if (args.model) await this._runAgn(['env', type, '--set', `LLM_MODEL=${args.model}`]);
+        if (args.model) await this._setModelEnv(type, args.model);
         if (args.baseUrl) await this._runAgn(['env', type, '--set', `LLM_BASE_URL=${args.baseUrl}`]);
         // Attach to this node's workspace so the agent shows up as a member.
         const r2 = await this._runAgn(['connect', name, n.token, '--endpoint', n.endpoint]);
@@ -199,9 +211,7 @@ class Daemon {
         // recreate (agn has no in-place path change) at the new path.
         const type = (args.type || '').trim();
         if (args.apiKey) await this._runAgn(['env', type, '--set', `LLM_API_KEY=${args.apiKey}`]);
-        if (args.model !== undefined) {
-          await this._runAgn(['env', type, '--set', `LLM_MODEL=${String(args.model || '')}`]);
-        }
+        if (args.model !== undefined) await this._setModelEnv(type, args.model);
         const newDir = (args.workingDir || '').trim();
         if (newDir && newDir !== (args.currentWorkingDir || '')) {
           try { fs.mkdirSync(newDir, { recursive: true }); } catch {}
@@ -255,6 +265,10 @@ class Daemon {
         // Run from home so a created agent's default working dir is sensible
         // (not the ~/.openagents config dir).
         cwd: os.homedir(),
+        // The daemon has no console of its own (it is spawned DETACHED), so a
+        // child without this gets a fresh console window — the blank black box
+        // that used to appear every time _refreshRuntimes() ran.
+        windowsHide: true,
       });
       let stdout = '';
       let stderr = '';
@@ -911,6 +925,9 @@ class Daemon {
       stdio: ['ignore', 'pipe', 'pipe'],
       env: getEnhancedEnv(opts.env),
       cwd: opts.cwd,
+      // Windows: cmd.exe would otherwise open a console window per agent (the
+      // daemon has none to inherit) and leave it up for the agent's lifetime.
+      windowsHide: true,
     };
 
     if (IS_WINDOWS) {

package/src/index.js

@@ -1,5 +1,9 @@
 'use strict';
 
+// Must run before anything captures a child_process reference: on Windows it
+// keeps every spawn from popping a stray console window. See win-console.js.
+require('./win-console').installWindowsHideDefault();
+
 const { Config } = require('./config');
 const { EnvManager } = require('./env');
 const { Registry } = require('./registry');

package/src/win-console.js

@@ -0,0 +1,85 @@
+'use strict';
+
+/**
+ * Stop Windows from popping a console window for every child process we spawn.
+ *
+ * Neither process that runs this code owns a console: the daemon is spawned
+ * DETACHED (`agn up --foreground`), and the launcher's Electron main process is
+ * a GUI app. On Windows, when a console-less process launches a console
+ * executable *without* CREATE_NO_WINDOW, the OS allocates a brand-new console
+ * for the child — an empty black cmd/Windows-Terminal window that pops to the
+ * foreground and steals focus. With stdio piped nothing is ever drawn in it,
+ * so what the user sees is a blank window appearing out of nowhere.
+ *
+ * That is the "命令框 keeps popping up" report: `_refreshRuntimes()` shells out
+ * to `agn runtimes --json` every two minutes, and the probe it runs keeps the
+ * window on screen for as long as it takes to check every installed CLI.
+ *
+ * Node exposes CREATE_NO_WINDOW as the `windowsHide` spawn option and most call
+ * sites pass it — but there are ~60 of them across the adapters and a single
+ * miss brings the window back. So the default lives here, applied once at the
+ * process entry points (src/index.js, src/cli.js) before any module has
+ * captured a reference to child_process.
+ *
+ * Two things this deliberately does NOT do:
+ *   - override an explicit `windowsHide: false` — the launcher opens a real
+ *     terminal for CLI sign-in that way, and that window is the point; and
+ *   - break interactive output: libuv only applies CREATE_NO_WINDOW when no
+ *     stdio handle is inherited, so `agn` run from a terminal (stdio 'inherit')
+ *     is unaffected by this and still prints where the user can see it.
+ */
+
+const childProcess = require('child_process');
+
+const PATCHED = Symbol.for('openagents.windowsHideDefault');
+const WRAPPED = ['spawn', 'spawnSync', 'exec', 'execSync', 'execFile', 'execFileSync'];
+
+/**
+ * Return a copy of `args` whose options object carries `windowsHide: true`.
+ *
+ * Every child_process signature ends with `[options][, callback]`, so the
+ * options object — if there is one — is the last non-function argument. The
+ * caller's object is copied rather than mutated: callers reuse option objects
+ * and must not see ours leak into their state.
+ */
+function withWindowsHide(args) {
+  const out = args.slice();
+  const cbIdx = typeof out[out.length - 1] === 'function' ? out.length - 1 : -1;
+  const optIdx = cbIdx === -1 ? out.length - 1 : cbIdx - 1;
+  const opts = optIdx >= 0 ? out[optIdx] : undefined;
+
+  if (opts && typeof opts === 'object' && !Array.isArray(opts)) {
+    if ('windowsHide' in opts) return args;  // explicit wins, either way
+    out[optIdx] = { ...opts, windowsHide: true };
+    return out;
+  }
+  // No options argument at all — insert one ahead of any callback.
+  out.splice(cbIdx === -1 ? out.length : cbIdx, 0, { windowsHide: true });
+  return out;
+}
+
+/**
+ * Default `windowsHide: true` for this process's child_process calls.
+ * No-op off Windows, and idempotent.
+ */
+function installWindowsHideDefault() {
+  if (process.platform !== 'win32') return;
+  if (childProcess[PATCHED]) return;
+
+  for (const name of WRAPPED) {
+    const original = childProcess[name];
+    if (typeof original !== 'function') continue;
+    const wrapper = function (...args) {
+      return original.apply(this, withWindowsHide(args));
+    };
+    // Keep util.promisify(exec) and friends working.
+    for (const sym of Object.getOwnPropertySymbols(original)) {
+      wrapper[sym] = original[sym];
+    }
+    Object.defineProperty(wrapper, 'name', { value: name });
+    childProcess[name] = wrapper;
+  }
+  childProcess[PATCHED] = true;
+}
+
+module.exports = { installWindowsHideDefault, withWindowsHide };