@openagents-org/agent-launcher 0.2.189 → 0.2.191

package/package.json

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

package/src/adapters/hermes.js

@@ -267,14 +267,23 @@ class HermesAdapter extends BaseAdapter {
   // Output parsing
   // ------------------------------------------------------------------
 
-  _parseHermesOutput(raw) {
+  _parseHermesOutput(raw, meta) {
     let sessionId = null;
     let body = raw;
 
-    const m = SESSION_ID_RE.exec(body);
-    if (m) {
-      sessionId = m[1];
-      body = body.replace(SESSION_ID_RE, '');
+    // Hermes -Q mode emits session_id to stderr (meta); the response body is
+    // on stdout (raw). Older Hermes printed session_id on stdout, so fall
+    // back to extracting it from the body when stderr carried none.
+    if (meta) {
+      const m = SESSION_ID_RE.exec(meta);
+      if (m) sessionId = m[1];
+    }
+    if (!sessionId) {
+      const m = SESSION_ID_RE.exec(body);
+      if (m) {
+        sessionId = m[1];
+        body = body.replace(SESSION_ID_RE, '');
+      }
     }
 
     const lines = [];
@@ -328,6 +337,7 @@ class HermesAdapter extends BaseAdapter {
     const proc = spawn(this._hermesBin, args, {
       env,
       stdio: ['ignore', 'pipe', 'pipe'],
+      cwd: this.workingDir,
       // No process group on Windows (can't signal one); windowsHide keeps a
       // console from flashing up.
       detached: !IS_WINDOWS,
@@ -358,7 +368,9 @@ class HermesAdapter extends BaseAdapter {
       throw new Error(`hermes exited with code ${exitCode}: ${detail}`);
     }
 
-    const { text, sessionId } = this._parseHermesOutput(stdout);
+    // Hermes -Q mode: response body on stdout, session metadata
+    // (session_id:, resume banner) on stderr — parse both streams.
+    const { text, sessionId } = this._parseHermesOutput(stdout, stderr);
     if (sessionId) {
       this._channelSessions[channelName] = sessionId;
       this._saveSessions();

package/src/adapters/kimi-stream.js

@@ -340,7 +340,9 @@ function classifyKimiError(info) {
     };
   }
 
-  if (/auth_error|401|unauthorized|invalid.{0,20}(api.?key|token)|credential/i.test(detail)) {
+  // Bounded: a bare 401 matched request ids, and `invalid.{0,20}token` turned
+  // "Invalid value for max_tokens" into a bad key and a `kimi login` hint.
+  if (/auth_error|\b401\b|unauthorized|invalid[\s_-]*(api[\s_-]?key|token|authentication)\b|credential/i.test(detail)) {
     return {
       kind: 'auth',
       userMessage:

package/src/adapters/workspace-prompt.js

@@ -415,28 +415,35 @@ function buildApiSkillsPrompt({ endpoint, workspaceId, token, agentName, channel
         `\`${curl} -s -X POST -H "${h}" -H "Content-Type: application/json"` +
         ` ${baseUrl}/v1/browser/tabs` +
         ` -d '{"url":"URL","network":"${workspaceId}",` +
-        `"source":"openagents:${agentName}"}'\`\n\n` +
+        `"source":"openagents:${agentName}"}'\`\n` +
+        'Tabs are **temporary** by default (closed after a while idle). Add ' +
+        '`"persistent":true` (and optionally `"name":"…"`) to open a **permanent** ' +
+        'tab whose login state is saved and reusable — humans see the two kinds ' +
+        'separately in their browser. Permanent slots are scarcer: use them only ' +
+        'for logins worth keeping.\n\n' +
         '**Navigate:**\n' +
         `\`${curl} -s -X POST -H "${h}" -H "Content-Type: application/json"` +
         ` ${baseUrl}/v1/browser/tabs/{tab_id}/navigate` +
-        ` -d '{"url":"URL"}'\`\n\n` +
+        ` -d '{"url":"URL","source":"openagents:${agentName}"}'\`\n\n` +
         '**Click element:**\n' +
         `\`${curl} -s -X POST -H "${h}" -H "Content-Type: application/json"` +
         ` ${baseUrl}/v1/browser/tabs/{tab_id}/click` +
-        ` -d '{"selector":"CSS_SELECTOR"}'\`\n\n` +
+        ` -d '{"selector":"CSS_SELECTOR","source":"openagents:${agentName}"}'\`\n\n` +
         '**Type text:**\n' +
         `\`${curl} -s -X POST -H "${h}" -H "Content-Type: application/json"` +
         ` ${baseUrl}/v1/browser/tabs/{tab_id}/type` +
-        ` -d '{"selector":"CSS_SELECTOR","text":"TEXT"}'\`\n` +
+        ` -d '{"selector":"CSS_SELECTOR","text":"TEXT","source":"openagents:${agentName}"}'\`\n` +
         '(add `"append":true` to keep existing text instead of replacing it)\n\n' +
         '**Press a key** (e.g. submit a form with Enter):\n' +
         `\`${curl} -s -X POST -H "${h}" -H "Content-Type: application/json"` +
         ` ${baseUrl}/v1/browser/tabs/{tab_id}/press_key` +
-        ` -d '{"key":"Enter"}'\`\n\n` +
+        ` -d '{"key":"Enter","source":"openagents:${agentName}"}'\`\n\n` +
         '**Run JavaScript** in the page (returns the result):\n' +
         `\`${curl} -s -X POST -H "${h}" -H "Content-Type: application/json"` +
         ` ${baseUrl}/v1/browser/tabs/{tab_id}/evaluate` +
-        ` -d '{"expression":"document.title"}'\`\n\n` +
+        ` -d '{"expression":"document.title","source":"openagents:${agentName}"}'\`\n` +
+        'The `source` field is how humans watching the shared browser see *who* is ' +
+        'acting — include it on every tab action.\n\n' +
         '**Close tab:**\n' +
         `\`${curl} -s -X DELETE -H "${h}" ${baseUrl}/v1/browser/tabs/{tab_id}\`\n\n` +
         '**Clicks/typing use CSS selectors only** (no pixel coordinates). If a ' +

package/src/agent-rows.js

@@ -7,6 +7,8 @@
 
 'use strict';
 
+const { isCliLogin } = require('./env');
+
 /**
  * Build one display row per configured agent from a connector.
  *
@@ -39,7 +41,7 @@ function loadAgentRows(connector) {
     let notReadyMsg = '';
     let health = null;
     try {
-      health = connector.healthCheck(agent.type || 'openclaw');
+      health = connector.healthCheck(agent.type || 'openclaw', { cliLogin: isCliLogin(agent.env), agentEnv: agent.env || {} });
       if (health && !health.ready) {
         // "Not installed" only when the executable is genuinely missing; an
         // installed-but-signed-out agent shows its login/config message, never

package/src/cli.js

@@ -582,7 +582,17 @@ async function cmdNode(connector, flags, positional) {
       process.exitCode = 1;
       return;
     }
-    const info = nodeCfg.gatherDeviceInfo();
+    let info;
+    try {
+      info = nodeCfg.gatherDeviceInfo();
+    } catch (e) {
+      // Pairing on top of an unreadable node.json would replace the pairings
+      // it holds; stop instead, so nothing is lost while it is sorted out.
+      print(`Could not read ${nodeCfg.NODE_FILE}: ${e.message}`);
+      print('Close anything that may have it open and try again.');
+      process.exitCode = 1;
+      return;
+    }
     if (flags.type) info.deviceType = flags.type;   // server | laptop | desktop
     if (flags.name) info.name = flags.name;
 
@@ -985,14 +995,16 @@ async function cmdProbe(connector, flags, positional) {
   const target = positional[0];
   if (!target) { print('Usage: agn probe <type|agent> [--json]'); return; }
 
-  // Accept an agent name as a convenience — probe its type.
+  // Accept an agent name — probe its type on that agent's own env, so a
+  // signed-in agent is tested on its sign-in rather than the type's key.
   let type = target;
+  let agentEnv;
   try {
     const agent = connector.config.getAgent(target);
-    if (agent) type = agent.type || 'openclaw';
+    if (agent) { type = agent.type || 'openclaw'; agentEnv = agent.env || {}; }
   } catch {}
 
-  const result = await connector.probeAgentType(type);
+  const result = await connector.probeAgentType(type, { agentEnv });
 
   if (flags && flags.json) {
     // Machine consumers (the daemon's probe_agent node command) read ONLY

package/src/daemon.js

@@ -10,6 +10,7 @@ const { spawn } = require('./wsl');
 const os = require('os');
 const { WorkspaceClient } = require('./workspace-client');
 const { listEndpointModels } = require('./model-list');
+const { AUTH_MODE_KEY, isCliLogin, stripForCliLogin, typeEnvFor } = require('./env');
 const { getEnhancedEnv, whichBinary, IS_WINDOWS, defaultAgentWorkdir } = require('./paths');
 
 /**
@@ -72,6 +73,28 @@ function endpointHost(value) {
  * Compatible with the Python SDK's daemon — reads the same config files,
  * writes the same status format, and supports the same command protocol.
  */
+/**
+ * Whether a node command carries a key for the agent. A blank key is no key:
+ * saving one would leave the agent not-ready, and clearing the sign-in
+ * marker on its account would flip a signed-in agent to key mode with
+ * nothing to run on. `useDeviceCredentials` means the device already holds
+ * the key — nothing to write.
+ */
+function _sentKey(args) {
+  const key = args && args.apiKey;
+  const present = typeof key === 'string' ? key.trim().length > 0 : !!key;
+  return present && !args.useDeviceCredentials;
+}
+
+/**
+ * Whether a node heartbeat failure is the workspace saying the node is gone:
+ * a 404 carrying the backend's own message (routers/nodes.py), not any 404.
+ */
+const NODE_GONE_MESSAGES = new Set(['Node not found', 'Workspace not found']);
+function _nodeGone(err) {
+  return !!err && err.status === 404 && NODE_GONE_MESSAGES.has(err.message);
+}
+
 class Daemon {
   constructor(config, envManager, registry) {
     this.config = config;
@@ -139,7 +162,9 @@ class Daemon {
     const type = agent.type || 'openclaw';
     this._probeInFlight.add(name);
     try {
-      const r = await this._runAgn(['probe', type, '--json']);
+      // By agent name, not type: the probe runs on this agent's own env, so a
+      // signed-in agent is tested on its sign-in, not the type's saved key.
+      const r = await this._runAgn(['probe', name, '--json']);
       let parsed = null;
       try { parsed = JSON.parse(r.stdout.trim()); } catch {}
       if (!parsed || typeof parsed !== 'object') {
@@ -190,7 +215,9 @@ class Daemon {
     const nodeCfg = require('./node-config');
     const pairings = nodeCfg.listPairings().filter((p) => p && p.node_id && p.token);
     if (!pairings.length) return;  // no node connected
-    const info = { ...nodeCfg.gatherDeviceInfo(), runtimes: this._runtimes || [], fs: this._buildFs() };
+    // deviceInfo, not gatherDeviceInfo: the heartbeat sends no device key, and
+    // must never be the thing that writes node.json.
+    const info = { ...nodeCfg.deviceInfo(), runtimes: this._runtimes || [], fs: this._buildFs() };
     await Promise.all(pairings.map((p) => this._nodeHeartbeatOne(nodeCfg, p, info)));
   }
 
@@ -248,8 +275,12 @@ class Daemon {
       // Without this the launcher kept showing "connected" long after a remote
       // removal, since node.json was only ever reconciled by the UI on demand.
       // Transient failures (timeouts, 5xx, auth blips) say nothing about the
-      // row's existence, so those are swallowed and retried next tick.
-      if (err && err.status === 404) {
+      // row's existence, so those are swallowed and retried next tick. So is a
+      // 404 the backend did not write: the hosting platform answers every
+      // request with its own 404 ("Application not found") while the service
+      // is unreachable, and taking that as the workspace's word unpaired every
+      // workspace on the device at once.
+      if (_nodeGone(err)) {
         try { nodeCfg.clearPairing(n.workspace_id); } catch {}
         this._nodeClients.delete(n.workspace_id);
         this._log(`node ${n.node_id} no longer recognized by workspace ${n.workspace_slug || n.workspace_id} — pairing cleared`);
@@ -347,7 +378,7 @@ class Daemon {
         // ever leaving the device. The endpoint goes out as a hostname, so
         // the workspace can tell a relay from the vendor its model list is for.
         let typeEnv = {};
-        try { typeEnv = this.envManager.load(a.type) || {}; } catch {}
+        try { typeEnv = typeEnvFor(a.type, this.envManager.load(a.type) || {}, this.registry, a.env); } catch {}
         const model = (a.env && a.env.LLM_MODEL) || typeEnv.LLM_MODEL || null;
         const apiKey = (a.env && a.env.LLM_API_KEY) || typeEnv.LLM_API_KEY || null;
         roster.push({
@@ -372,9 +403,11 @@ class Daemon {
    * builds its env: LLM_BASE_URL or a provider variable (OPENAI_BASE_URL,
    * ANTHROPIC_BASE_URL, …) saved for it or mapped by resolve_env, and failing
    * those, the daemon's own environment for the provider variable this type's
-   * LLM_BASE_URL maps to, which the spawned CLI inherits.
+   * LLM_BASE_URL maps to, which the spawned CLI inherits. A signed-in agent
+   * has none: _buildAgentEnv drops every saved endpoint for it.
    */
   _configuredBaseUrl(a, typeEnv) {
+    if (isCliLogin(a.env)) return null;
     const saved = { ...typeEnv, ...(a.env || {}) };
     let env = saved;
     try { env = { ...saved, ...this.envManager.resolve(a.type, saved, this.registry) }; } catch {}
@@ -470,7 +503,12 @@ class Daemon {
    */
   _saveNodeAgentEnv(name, type, args) {
     const changes = {};
-    if (args.apiKey && !args.useDeviceCredentials) changes.LLM_API_KEY = args.apiKey;
+    if (_sentKey(args)) {
+      changes.LLM_API_KEY = args.apiKey;
+      // A key sent for the agent means it runs on that key: a sign-in marker
+      // left from the launcher would strip it again at launch.
+      changes[AUTH_MODE_KEY] = '';
+    }
     if (args.baseUrl !== undefined) changes.LLM_BASE_URL = args.baseUrl;
     if (args.model !== undefined) {
       const existing = this.config.getAgent(name);
@@ -585,7 +623,7 @@ async _runNodeCommand(n, cmd) {
         // Optional credentials for API-key agents (generic → provider mapping
         // happens in env resolution). `useDeviceCredentials` means the device
         // already holds them — nothing to write.
-        if (args.apiKey && !args.useDeviceCredentials)
+        if (_sentKey(args))
           await this._runAgn(['env', type, '--set', `LLM_API_KEY=${args.apiKey}`]);
         if (args.model) await this._setModelEnv(type, args.model);
         if (args.baseUrl) await this._runAgn(['env', type, '--set', `LLM_BASE_URL=${args.baseUrl}`]);
@@ -622,7 +660,7 @@ async _runNodeCommand(n, cmd) {
         // restart it so the change takes effect. Working-dir changes require a
         // recreate (agn has no in-place path change) at the new path.
         const type = (args.type || '').trim();
-        if (args.apiKey && !args.useDeviceCredentials)
+        if (_sentKey(args))
           await this._runAgn(['env', type, '--set', `LLM_API_KEY=${args.apiKey}`]);
         if (args.model !== undefined) await this._setModelEnv(type, args.model);
         if (args.baseUrl !== undefined) await this._runAgn(['env', type, '--set', `LLM_BASE_URL=${args.baseUrl}`]);
@@ -1519,11 +1557,9 @@ async _runNodeCommand(n, cmd) {
 
   _buildAgentEnv(agentCfg) {
     const type = agentCfg.type || 'openclaw';
-    const saved = this.envManager.load(type);
-    const mergedSaved = { ...saved, ...(agentCfg.env || {}) };
-    const resolved = this.envManager.resolve(type, mergedSaved, this.registry);
-    const merged = { ...mergedSaved, ...resolved };
-    return { ...process.env, ...merged };
+    const merged = this.envManager.getForAgent(type, this.registry, agentCfg.env);
+    // A signed-in agent drops every key, the launcher's own environment's too.
+    return stripForCliLogin(type, { ...process.env, ...merged }, this.registry, agentCfg.env);
   }
 
   _agentConfigFingerprint(agentCfg) {

package/src/env.js

@@ -112,6 +112,119 @@ class EnvManager {
     const resolved = this.resolve(agentType, saved, registry);
     return { ...saved, ...resolved };
   }
+
+  /**
+   * The saved env one agent runs on: the part of <type>.env it takes (see
+   * typeEnvFor) under its own env, resolved. The daemon launches the agent on
+   * this over its own environment, and readiness judges the agent on it too.
+   */
+  getForAgent(agentType, registry, agentEnv) {
+    const saved = { ...typeEnvFor(agentType, this.load(agentType), registry, agentEnv), ...(agentEnv || {}) };
+    const resolved = this.resolve(agentType, saved, registry);
+    return { ...saved, ...resolved };
+  }
+}
+
+/**
+ * Set on an agent's own env when it signs in through its CLI (`codex login`,
+ * `claude auth login`) instead of a key. Keys stay shared per type in
+ * <type>.env and the launcher's own environment, and a CLI prefers a key it
+ * is handed over its account session, so without this an agent created on
+ * the sign-in tab still ran on whatever key was saved there earlier.
+ */
+const AUTH_MODE_KEY = 'OPENAGENTS_AUTH_MODE';
+const CLI_LOGIN = 'cli_login';
+
+/**
+ * Whether the agent signs in through its CLI. Read from the agent's own env
+ * only: a marker in <type>.env or the launcher's environment would otherwise
+ * strip the key of every agent of that type, keyed ones included.
+ */
+function isCliLogin(agentEnv) {
+  return !!agentEnv && agentEnv[AUTH_MODE_KEY] === CLI_LOGIN;
+}
+
+/**
+ * Keys and endpoints a CLI reads under a name of its own that no registry
+ * field or readiness check declares (the launcher's auth-specs.ts offers the
+ * endpoints). Named per type rather than by suffix: the env stripped is the
+ * daemon's whole environment, where *_BASE_URL also names endpoints that are
+ * not the model's. CODEX_API_KEY: the Codex CLI honors it over its ChatGPT
+ * sign-in, so one set system-wide would defeat the sign-in just as
+ * OPENAI_API_KEY does.
+ */
+const NATIVE_CREDENTIALS = {
+  codex: ['CODEX_API_KEY'],
+  gemini: ['GOOGLE_GEMINI_BASE_URL'],
+  antigravity: ['GOOGLE_GEMINI_BASE_URL'],
+};
+
+/**
+ * The variables that carry a key or an endpoint for this agent type: its
+ * password and *_BASE_URL fields, what LLM_API_KEY / LLM_BASE_URL resolve to,
+ * and the *_API_KEY variables its readiness check accepts (Gemini has no
+ * fields at all, and reads GEMINI_API_KEY / GOOGLE_API_KEY). Only the
+ * *_API_KEY ones: that list also holds models and tokens other tools share
+ * (MSWEA_MODEL_NAME, GH_TOKEN). The model is not among them, it applies to a
+ * sign-in as well. So is
+ * CLAUDE_CODE_OAUTH_TOKEN: `claude setup-token` makes it from the account
+ * sign-in, so it is how a signed-in claude authenticates, not a key to drop.
+ */
+function credentialKeys(agentType, registry) {
+  const keys = new Set(['LLM_API_KEY', 'LLM_BASE_URL', ...(NATIVE_CREDENTIALS[agentType] || [])]);
+  if (!registry) return keys;
+  for (const field of registry.getEnvFields?.(agentType) || []) {
+    if (field.password || /BASE_URL$/.test(field.name || '')) keys.add(field.name);
+  }
+  for (const rule of registry.getResolveRules?.(agentType) || []) {
+    if (keys.has(rule.from) && rule.to) keys.add(rule.to);
+  }
+  const checkReady = registry.getEntry?.(agentType)?.check_ready;
+  for (const name of (checkReady && checkReady.env_vars) || []) {
+    if (/_API_KEY$/.test(name)) keys.add(name);
+  }
+  return keys;
+}
+
+/**
+ * The variables that pick the model: LLM_MODEL, what it resolves to
+ * (CODEX_MODEL, ANTHROPIC_MODEL), and a type's own *_MODEL fields.
+ */
+function modelKeys(agentType, registry) {
+  const keys = new Set(['LLM_MODEL']);
+  if (!registry) return keys;
+  for (const field of registry.getEnvFields?.(agentType) || []) {
+    if (/_MODEL(_NAME)?$/.test(field.name || '')) keys.add(field.name);
+  }
+  for (const rule of registry.getResolveRules?.(agentType) || []) {
+    if (rule.from === 'LLM_MODEL' && rule.to) keys.add(rule.to);
+  }
+  return keys;
+}
+
+/**
+ * The part of <type>.env an agent runs on. All of it for an agent on a key.
+ * A signed-in agent takes none of its keys, and none of its model either:
+ * that model was picked for the key's endpoint (a relay's
+ * openai-gpt-oss-20b), which the account behind a sign-in does not serve.
+ * Its model is the one in its own env, else the CLI's default.
+ */
+function typeEnvFor(agentType, typeEnv, registry, agentEnv) {
+  if (!isCliLogin(agentEnv)) return typeEnv;
+  const out = stripForCliLogin(agentType, typeEnv, registry, agentEnv);
+  for (const key of modelKeys(agentType, registry)) delete out[key];
+  return out;
+}
+
+/**
+ * `env` with every credential removed when the agent's own env (`agentEnv`)
+ * marks a sign-in, or unchanged for an agent that runs on a key.
+ */
+function stripForCliLogin(agentType, env, registry, agentEnv) {
+  if (!isCliLogin(agentEnv)) return env;
+  const out = { ...env };
+  for (const key of credentialKeys(agentType, registry)) delete out[key];
+  return out;
 }
 
 /**
@@ -128,4 +241,6 @@ function normalizeAnthropicBase(url) {
   return String(url || '').trim().replace(/\/+$/, '').replace(/\/v1$/i, '');
 }
 
-module.exports = { EnvManager };
+module.exports = {
+  EnvManager, AUTH_MODE_KEY, CLI_LOGIN, isCliLogin, credentialKeys, modelKeys, stripForCliLogin, typeEnvFor,
+};

package/src/index.js

@@ -69,8 +69,8 @@ class AgentConnector {
     return this.installer.isInstalled(agentType);
   }
 
-  healthCheck(agentType) {
-    return this.installer.healthCheck(agentType);
+  healthCheck(agentType, opts) {
+    return this.installer.healthCheck(agentType, opts);
   }
 
   // -- Agent CRUD --

package/src/installer.js

@@ -512,7 +512,15 @@ class Installer {
    * Health check — binary existence + version.
    * @returns {{ installed: boolean, binary: string|null, version: string|null }}
    */
-  healthCheck(agentType) {
+  /**
+   * `opts.cliLogin` checks one agent that signs in through its CLI: the core
+   * drops every key for it at launch, so a key saved for the type or set in
+   * the daemon's environment must not make it ready.
+   *
+   * `opts.agentEnv` is that agent's own env. With it the agent is judged on
+   * the env the daemon launches it on, not on <type>.env alone.
+   */
+  healthCheck(agentType, opts = {}) {
     const entry = this.registry.getEntry(agentType);
     if (entry?.install?.api_only) {
       const info = this.getInstallInfo(agentType);
@@ -532,7 +540,7 @@ class Installer {
         };
       }
 
-      const apiReadiness = this._evaluateReadiness(agentType, entry, null);
+      const apiReadiness = this._evaluateReadiness(agentType, entry, null, opts);
       return {
         installed: true,
         binary: null,
@@ -568,7 +576,7 @@ class Installer {
     const versionCmd = checkCmd || this._versionProbeCommand(binary);
 
     const version = this._detectVersion(binary, versionCmd);
-    const readiness = this._evaluateReadiness(agentType, entry, binary);
+    const readiness = this._evaluateReadiness(agentType, entry, binary, opts);
 
     // Generic minimum-version gate (no per-agent special-casing). An entry opts
     // in by declaring `install.min_version`. Below the floor we keep
@@ -776,7 +784,7 @@ class Installer {
     return { compatible: true, minVersion, message: null };
   }
 
-  _evaluateReadiness(agentType, entry, binary) {
+  _evaluateReadiness(agentType, entry, binary, opts = {}) {
     const checkReady = entry?.check_ready;
     if (!checkReady) {
       return {
@@ -788,10 +796,16 @@ class Installer {
       };
     }
 
-    const savedEnv = this.env.getEffective(agentType, this.registry);
+    // A key set on the agent itself (the workspace saves it there, as
+    // LLM_API_KEY) never reaches <type>.env, so judged on that file alone a
+    // Kimi agent that answered fine read "Not configured — … run: kimi login".
+    const savedEnv = opts.agentEnv
+      ? this.env.getForAgent(agentType, this.registry, opts.agentEnv)
+      : this.env.getEffective(agentType, this.registry);
     const directEnv = this._hasAllValues(process.env, checkReady.env_all);
     const directSaved = this._hasAllValues(savedEnv, checkReady.saved_env_all || checkReady.env_all);
-    const directReady = directEnv || directSaved;
+    const keyed = !opts.cliLogin;
+    const directReady = keyed && (directEnv || directSaved);
     // env_vars must be satisfiable by the SAVED (and resolved) per-agent env,
     // not only the daemon's own process env. The workspace configure flow
     // saves LLM_API_KEY, which resolve rules map to e.g. ANTHROPIC_AUTH_TOKEN
@@ -799,10 +813,10 @@ class Installer {
     // alone made a perfectly working key-configured agent read "Not logged
     // in" (health banner + failed smoke test) while chat answered fine, with
     // guidance telling the user to configure the very key they had saved.
-    const envAnyReady =
+    const envAnyReady = keyed && (
       this._hasAnyValue(process.env, checkReady.env_vars) ||
-      this._hasAnyValue(savedEnv, checkReady.env_vars);
-    const savedAnyReady = !!(checkReady.saved_env_key && savedEnv[checkReady.saved_env_key]);
+      this._hasAnyValue(savedEnv, checkReady.env_vars));
+    const savedAnyReady = keyed && !!(checkReady.saved_env_key && savedEnv[checkReady.saved_env_key]);
     // A registry entry may require a non-empty JSON object rather than mere
     // parseability. In that mode the stricter _evaluateCredsFile path below is
     // authoritative; the legacy parser treats an empty {} as ready.

package/src/node-config.js

@@ -16,30 +16,64 @@ const crypto = require('crypto');
 const NODE_DIR = path.join(os.homedir(), '.openagents');
 const NODE_FILE = path.join(NODE_DIR, 'node.json');
 
-function loadNode() {
+/**
+ * The record on disk: null when there is no file, and a throw when there is
+ * one that cannot be read or parsed (half-written by another process, or held
+ * by an antivirus scan on Windows). Every writer reads through this, so an
+ * unreadable file is left alone rather than rebuilt from nothing — which
+ * dropped every pairing and minted a new device key.
+ */
+function readNode() {
+  let raw;
   try {
-    if (fs.existsSync(NODE_FILE)) return JSON.parse(fs.readFileSync(NODE_FILE, 'utf-8'));
-  } catch {}
-  return null;
+    raw = fs.readFileSync(NODE_FILE, 'utf-8');
+  } catch (err) {
+    if (err && err.code === 'ENOENT') return null;
+    throw err;
+  }
+  return JSON.parse(raw);
 }
 
+/** Lenient read for display and heartbeat: an unreadable file counts as none. */
+function loadNode() {
+  try { return readNode(); } catch { return null; }
+}
+
+/**
+ * Written through a temp file and a rename, so a reader in the other process
+ * (launcher or daemon) sees the old record or the new one, never a torn one.
+ */
 function saveNode(data) {
   try {
     fs.mkdirSync(NODE_DIR, { recursive: true });
-    fs.writeFileSync(NODE_FILE, JSON.stringify(data, null, 2));
-    try { fs.chmodSync(NODE_FILE, 0o600); } catch {}  // holds the workspace token
+    const tmp = `${NODE_FILE}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 0o600 });  // holds the workspace token
+    try {
+      fs.renameSync(tmp, NODE_FILE);
+    } catch {
+      // Windows refuses the rename while another process holds the target.
+      try { fs.unlinkSync(tmp); } catch {}
+      fs.writeFileSync(NODE_FILE, JSON.stringify(data, null, 2));
+    }
+    try { fs.chmodSync(NODE_FILE, 0o600); } catch {}
   } catch {}
 }
 
-/** Stable per-device id, generated once and persisted. */
+/** Stable per-device id, generated once and persisted. Throws if node.json is unreadable. */
 function getOrCreateNodeKey() {
-  const existing = loadNode();
+  const existing = readNode();
   if (existing && existing.node_key) return existing.node_key;
   const key = (crypto.randomUUID && crypto.randomUUID()) || crypto.randomBytes(16).toString('hex');
   saveNode({ ...(existing || {}), node_key: key });
   return key;
 }
 
+function pairingsOf(record) {
+  if (!record) return [];
+  if (record.pairings && record.pairings.length) return record.pairings;
+  return record.workspace_id ? [record] : [];
+}
+
 /**
  * Every workspace this device is paired to, most recent first.
  *
@@ -49,10 +83,7 @@ function getOrCreateNodeKey() {
  * existed carry a single top-level pairing, which is reconstructed here.
  */
 function listPairings() {
-  const record = loadNode();
-  if (!record) return [];
-  if (record.pairings && record.pairings.length) return record.pairings;
-  return record.workspace_id ? [record] : [];
+  return pairingsOf(loadNode());
 }
 
 /**
@@ -67,7 +98,7 @@ function recordPairing(nodeKey, pairing) {
   const stamped = { ...pairing, paired_at: new Date().toISOString() };
   const pairings = [
     stamped,
-    ...listPairings().filter((p) => p.workspace_id !== pairing.workspace_id),
+    ...pairingsOf(readNode()).filter((p) => p.workspace_id !== pairing.workspace_id),
   ];
   saveNode({ node_key: nodeKey, ...stamped, pairings });
 }
@@ -86,12 +117,12 @@ function recordPairing(nodeKey, pairing) {
  * @returns the pairing that was dropped, or null if there was no such pairing.
  */
 function clearPairing(workspaceId) {
-  const record = loadNode();
+  const record = readNode();
   if (!record) return null;
   const target = workspaceId || record.workspace_id;
   if (!target) return null;
 
-  const pairings = listPairings();
+  const pairings = pairingsOf(record);
   const dropped = pairings.find((p) => p.workspace_id === target);
   if (!dropped) return null;
 
@@ -114,12 +145,11 @@ function inferDeviceType() {
   return 'server';  // linux is typically a server/VM in this context
 }
 
-/** Device info sent on redeem/heartbeat. */
-function gatherDeviceInfo() {
+/** Device info sent on every heartbeat. Reads and writes nothing on disk. */
+function deviceInfo() {
   let launcherVersion = '';
   try { launcherVersion = require('../package.json').version; } catch {}
   return {
-    nodeKey: getOrCreateNodeKey(),
     hostname: os.hostname(),
     os: os.platform(),
     deviceType: inferDeviceType(),
@@ -127,7 +157,13 @@ function gatherDeviceInfo() {
   };
 }
 
+/** Device info sent on redeem, with the device key (minted on first pairing). */
+function gatherDeviceInfo() {
+  return { nodeKey: getOrCreateNodeKey(), ...deviceInfo() };
+}
+
 module.exports = {
+  readNode,
   loadNode,
   saveNode,
   listPairings,
@@ -135,6 +171,7 @@ module.exports = {
   clearPairing,
   getOrCreateNodeKey,
   inferDeviceType,
+  deviceInfo,
   gatherDeviceInfo,
   NODE_FILE,
   NODE_DIR,

package/src/probe.js

@@ -33,6 +33,7 @@ const { spawn } = require('./wsl');
 const { getEnhancedEnv } = require('./paths');
 const { shouldUseShellForBinary } = require('./adapters/health-status');
 const { formatAuthGuidance } = require('./auth-guidance');
+const { isCliLogin, stripForCliLogin, typeEnvFor } = require('./env');
 
 const PROBE_PROMPT = 'hi';
 const DEFAULT_TIMEOUT_MS = 90_000;
@@ -98,7 +99,14 @@ function authFlavor(entry, agentEnv) {
   const cr = (entry && entry.check_ready) || {};
   const envCfg = (entry && entry.env_config) || [];
   const hasKeyField = envCfg.some((f) => f && /key/i.test(f.name || ''));
-  const hasSavedKey = !!(agentEnv && (agentEnv.LLM_API_KEY || agentEnv.OPENAI_API_KEY || agentEnv.ANTHROPIC_API_KEY));
+  // The type's own key names count too: a Kimi agent on KIMI_API_KEY whose
+  // key was rejected was told its sign-in had expired and to run kimi login.
+  const keyNames = [
+    'LLM_API_KEY', 'OPENAI_API_KEY', 'ANTHROPIC_API_KEY', cr.saved_env_key,
+    ...(cr.env_vars || []).filter((k) => /_API_KEY$/.test(k)),
+    ...envCfg.filter((f) => f && f.password).map((f) => f.name),
+  ];
+  const hasSavedKey = !!agentEnv && keyNames.some((k) => k && agentEnv[k]);
   if (hasSavedKey || (hasKeyField && !cr.login_command)) return 'api_key';
   if (cr.login_command) return 'cli_login';
   return hasKeyField ? 'api_key' : 'cli_login';
@@ -287,16 +295,22 @@ async function probeAgentType(connector, type, opts = {}) {
     return done({ ok: false, method: 'none', code: CODE.UNKNOWN_TYPE, message: `Unknown agent type '${type}'` });
   }
 
+  // A signed-in agent is ready on its sign-in alone: judged on the type, a
+  // key it will never be given made it "pass" with no login at all.
+  const cliLogin = isCliLogin(opts.agentEnv);
   let health = {};
-  try { health = connector.healthCheck(type) || {}; } catch (e) {
+  try { health = connector.healthCheck(type, { cliLogin, agentEnv: opts.agentEnv }) || {}; } catch (e) {
     health = { installed: false, ready: false, message: e.message };
   }
 
+  // opts.agentEnv is one agent's own env, layered over the type's the way
+  // the daemon builds it; a signed-in agent then carries no key from either.
   let agentEnv = {};
   try {
-    const saved = connector.getAgentEnv(type) || {};
+    const typeEnv = typeEnvFor(type, connector.getAgentEnv(type) || {}, connector.registry, opts.agentEnv);
+    const saved = { ...typeEnv, ...(opts.agentEnv || {}) };
     const resolved = connector.resolveAgentEnv(type, saved) || {};
-    agentEnv = { ...saved, ...resolved };
+    agentEnv = stripForCliLogin(type, { ...saved, ...resolved }, connector.registry, opts.agentEnv);
   } catch {}
 
   if (!health.installed) {
@@ -321,7 +335,7 @@ async function probeAgentType(connector, type, opts = {}) {
 
   const timeoutMs = opts.timeoutMs
     || (entry.probe && entry.probe.timeout_s ? entry.probe.timeout_s * 1000 : DEFAULT_TIMEOUT_MS);
-  const env = { ...getEnhancedEnv(), ...agentEnv };
+  const env = stripForCliLogin(type, { ...getEnhancedEnv(), ...agentEnv }, connector.registry, opts.agentEnv);
 
   // Hoisted above the CLI tier: a failing CLI probe consults it too (below).
   const hasApiKey = !!(agentEnv.LLM_API_KEY || agentEnv.OPENAI_API_KEY || agentEnv.ANTHROPIC_API_KEY

package/src/tui.js

@@ -14,6 +14,7 @@ const fs = require('fs');
 const { spawn } = require('child_process');
 const { getExtraBinDirs } = require('./paths');
 const { hasCredentialMetadata, formatAuthGuidance } = require('./auth-guidance');
+const { isCliLogin } = require('./env');
 
 const IS_WINDOWS = process.platform === 'win32';
 
@@ -774,7 +775,7 @@ function createTUI() {
       const checkReady = entry && entry.check_ready;
       if (hasCredentialMetadata(checkReady)) {
         let health = null;
-        try { health = connector.healthCheck(agent.type); } catch {}
+        try { health = connector.healthCheck(agent.type, { cliLogin: isCliLogin(agent.env), agentEnv: agent.env || {} }); } catch {}
         const g = formatAuthGuidance(entry, health);
         const tag = g.ready ? 'green-fg' : 'yellow-fg';
         log(`{bold}{${tag}}${entry.label || agent.type} authentication: ${g.ready ? 'Ready' : 'Not ready'}{/}{/bold}`);