@openagents-org/agent-launcher 0.2.192 → 0.2.194

package/src/daemon.js

@@ -2,6 +2,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
 const { execSync, execFileSync } = require('child_process');
 // spawn() here is the WSL bridge from ./wsl: same signature as
 // child_process.spawn, and a straight pass-through unless the resolved CLI
@@ -10,8 +11,19 @@ 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 { supportsCliModels } = require('./cli-models');
+const { AUTH_MODE_KEY, isCliLogin, modelKeys, stripForCliLogin, typeEnvFor } = require('./env');
 const { getEnhancedEnv, whichBinary, IS_WINDOWS, defaultAgentWorkdir } = require('./paths');
+const { LogWriter } = require('./log-writer');
+
+// A signed-in agent's model list is asked for again after this long. What a
+// CLI is offered changes when the CLI is upgraded (a vendor holds new models
+// back from old versions), so the upgrade should show within the hour.
+const CLI_MODELS_MAX_AGE_MS = 3600 * 1000;
+// A sign-in whose CLI has never answered is asked again sooner: the first ask
+// may have failed for a passing reason (a slow start, an update mid-way). A
+// little under the 10-minute sweep, so the next pass retries it.
+const CLI_MODELS_RETRY_MS = 9 * 60 * 1000;
 
 /**
  * Mask an API key for display (same shape the workspace backend uses for
@@ -110,7 +122,7 @@ class Daemon {
     this._cmdInterval = null;
     this._nodeHeartbeatInterval = null;  // device-level heartbeat (connect-a-node)
     this._displayNameInterval = null;    // pulls workspace-side renames back
-    this._nodeClients = new Map();       // workspace_id -> WorkspaceClient, one per pairing
+    this._nodeClients = new Map();       // node_id -> WorkspaceClient, one per private connection
     this._runningCommands = new Set();   // node-command ids currently executing
     this._runtimes = [];                 // detected agent runtimes for the node view
     this._runtimesInterval = null;
@@ -118,6 +130,10 @@ class Daemon {
     this._probeInterval = null;
     this._probeStartupTimer = null;
     this._probeInFlight = new Set();     // types being probed right now
+    this._cliModels = {};                // sign-in key → { models, askedAt } from the agents' own CLI
+    this._cliModelsInFlight = new Set(); // sign-in keys whose CLI is being asked right now
+    this._cliModelsStartupTimer = null;
+    this._cliModelsInterval = null;
     this._reloadInFlight = null;  // serialize concurrent _reload() calls
   }
 
@@ -198,6 +214,98 @@ class Daemon {
     this._nodeHeartbeat();
   }
 
+  // ── Models a signed-in agent's account is offered ──────────────────────
+  // An agent on a subscription sign-in has no endpoint whose models can be
+  // listed, so its own CLI is asked (see cli-models.js). The answer rides the
+  // heartbeat's roster as agents[].cliModels, which puts it in front of the
+  // workspace's model picker without a command round trip. Kept in memory
+  // only: asking again after a restart costs a CLI start, not a model call.
+
+  /**
+   * Whether this agent runs on its CLI's own sign-in: a type whose CLI can
+   * say what the account is offered, calling that CLI's default endpoint,
+   * with no key the CLI would be handed instead.
+   */
+  _onCliSignIn(a) {
+    if (!supportsCliModels(a.type)) return false;
+    const endpoint = this._agentEndpoint(a);
+    return !endpoint.baseUrl && !endpoint.apiKey;
+  }
+
+  /**
+   * One key per sign-in. Agents of a type run one CLI on one account unless
+   * their own env says otherwise (a token or a config dir of their own), so
+   * those with the same env share an answer: a device with nine Claude agents
+   * starts the CLI once, not nine times. The model each runs is left out, it
+   * does not change what the account is offered. Hashed, since that env can
+   * hold a token.
+   */
+  _cliModelsKey(a) {
+    const skip = modelKeys(a.type, this.registry);
+    const own = Object.entries(a.env || {})
+      .filter(([k]) => !skip.has(k))
+      .sort(([x], [y]) => (x < y ? -1 : x > y ? 1 : 0));
+    return crypto.createHash('sha256').update(JSON.stringify([a.type, own])).digest('hex');
+  }
+
+  /**
+   * Ask an agent's CLI for its models via a child `agn models <name> --json`
+   * (off the event loop, and on that agent's own env, like a probe).
+   * Resolves true when the list it keeps for that sign-in changed.
+   */
+  async _listCliModels(a) {
+    const key = this._cliModelsKey(a);
+    if (this._cliModelsInFlight.has(key)) return false;
+    this._cliModelsInFlight.add(key);
+    try {
+      const r = await this._runAgn(['models', a.name, '--json']);
+      let parsed = null;
+      try { parsed = JSON.parse(r.stdout.trim()); } catch {}
+      const models = parsed && parsed.ok && Array.isArray(parsed.models) ? parsed.models : [];
+      const last = this._cliModels[key];
+      // A CLI that would not answer keeps the list it last gave: that is
+      // still the best answer there is.
+      const kept = models.length ? models : ((last && last.models) || null);
+      this._cliModels[key] = { models: kept, askedAt: Date.now() };
+      return JSON.stringify(kept) !== JSON.stringify((last && last.models) || null);
+    } finally {
+      this._cliModelsInFlight.delete(key);
+    }
+  }
+
+  /** Ask in the background for an agent that was just created or reconfigured. */
+  _askCliModels(name) {
+    let agent = null;
+    try { agent = this.config.getAgent(name); } catch {}
+    if (!agent || !this._onCliSignIn(agent)) return;
+    // A changed list goes out on a heartbeat now, not on the next tick.
+    this._listCliModels(agent)
+      .then((changed) => (changed ? this._nodeHeartbeat() : undefined))
+      .catch(() => {});
+  }
+
+  /**
+   * Periodic sweep: ask for every sign-in whose list is missing or has aged
+   * out, and forget the ones no agent is on any more. Sequential, like the
+   * probe sweep: there is no hurry.
+   */
+  async _refreshCliModels() {
+    const signIns = new Set();
+    for (const a of this.config.getAgents()) {
+      if (!a.network || !this._onCliSignIn(a)) continue;
+      const key = this._cliModelsKey(a);
+      if (signIns.has(key)) continue;
+      signIns.add(key);
+      const last = this._cliModels[key];
+      const maxAge = last && last.models ? CLI_MODELS_MAX_AGE_MS : CLI_MODELS_RETRY_MS;
+      if (last && Date.now() - last.askedAt < maxAge) continue;
+      try { await this._listCliModels(a); } catch {}
+    }
+    for (const key of Object.keys(this._cliModels)) {
+      if (!signIns.has(key)) delete this._cliModels[key];
+    }
+  }
+
   /**
    * Heartbeat this device (node) to EVERY workspace it is paired to,
    * independent of any agent, so each workspace's "connected devices" view
@@ -239,7 +347,7 @@ class Daemon {
       if (!info || !info.networkRef || info._credRestartPending) continue;
       if (!this._adapters || !this._adapters[name]) continue;
       let fresh = null;
-      try { fresh = this._resolveAgentNetwork(info.networkRef); } catch { /* keep running on the current token */ }
+      try { fresh = this._resolveAgentNetwork(info.networkRef, info.connectionId); } catch { /* keep running on the current token */ }
       if (!fresh || !fresh.token || fresh.token === info.credentialToken) continue;
       // Flag on the CURRENT info object: restartAgent replaces it with a fresh
       // one on relaunch, so the flag cannot wedge the watch permanently.
@@ -247,17 +355,17 @@ class Daemon {
       this._log(`${name}: workspace credential for '${info.networkRef}' rotated (device re-paired) — restarting to pick up the new token`);
       this.restartAgent(name).catch((e) => {
         info._credRestartPending = false;
-        this._log(`${name}: credential-rotation restart failed: ${e.message}`);
+        this._log(`${name}: credential-rotation restart failed: ${e.message}`, 'warn');
       });
     }
   }
 
   /** The WorkspaceClient for one pairing, created on first use and reused. */
   _nodeClientFor(n) {
-    let client = this._nodeClients.get(n.workspace_id);
+    let client = this._nodeClients.get(n.node_id);
     if (!client) {
       client = new WorkspaceClient(n.endpoint);
-      this._nodeClients.set(n.workspace_id, client);
+      this._nodeClients.set(n.node_id, client);
     }
     return client;
   }
@@ -281,8 +389,8 @@ class Daemon {
       // 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);
+        try { nodeCfg.clearPairing(n.workspace_id, n.node_id); } catch {}
+        this._nodeClients.delete(n.node_id);
         this._log(`node ${n.node_id} no longer recognized by workspace ${n.workspace_slug || n.workspace_id} — pairing cleared`);
       }
       return;  // nothing more to do for this pairing this tick
@@ -351,7 +459,13 @@ class Daemon {
    */
   _agentOnNodeWorkspace(a, node) {
     if (!a || !a.network || !node) return false;
-    return a.network === node.workspace_slug || a.network === node.workspace_id;
+    if (a.network !== node.workspace_slug && a.network !== node.workspace_id) return false;
+    if (a.node_id) return a.node_id === node.node_id;
+    // Legacy agents may bind automatically only when the workspace is unambiguous.
+    const candidates = require('./node-config').listPairings().filter(
+      (p) => p.workspace_id === node.workspace_id && p.workspace_id,
+    );
+    return candidates.length <= 1;
   }
 
   /**
@@ -381,6 +495,9 @@ class Daemon {
         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;
+        // What the agent's own CLI says its signed-in account can run. Null
+        // for an agent on a key or a relay, and until its CLI has answered.
+        const listed = supportsCliModels(a.type) ? this._cliModels[this._cliModelsKey(a)] : null;
         roster.push({
           name: a.name,
           type: a.type || 'unknown',
@@ -389,6 +506,7 @@ class Daemon {
           workingDir: a.path || null,
           apiKeyMasked: apiKey ? maskApiKey(apiKey) : null,
           baseUrlHost: endpointHost(this._configuredBaseUrl(a, typeEnv)),
+          cliModels: listed && listed.models && this._onCliSignIn(a) ? listed.models : null,
           probe: this._probes[a.name] || null,
         });
       }
@@ -583,7 +701,7 @@ class Daemon {
     }
     for (const [key, value] of Object.entries(config)) {
       if (!allowed.has(key)) {
-        this._log(`config for '${type}': refused non-env_config key '${key}'`);
+        this._log(`config for '${type}': refused non-env_config key '${key}'`, 'warn');
         continue;
       }
       if (value === null || value === undefined) continue;
@@ -634,7 +752,7 @@ async _runNodeCommand(n, cmd) {
         // pass and no /v1/token/resolve round-trip to fail (the outage class
         // that used to break remote installs).
         const r2 = await this._runAgn([
-          'connect', name, '--workspace', n.workspace_slug || n.workspace_id,
+          'connect', name, '--workspace', n.workspace_slug || n.workspace_id, '--connection', n.node_id,
         ]);
         if (r2.code !== 0) throw new Error(r2.stderr || r2.stdout || 'connect failed');
         ok = true;
@@ -643,6 +761,7 @@ async _runNodeCommand(n, cmd) {
         // full timeout — never hold the create result hostage). The outcome
         // reaches the workspace via the heartbeat's agents[].probe.
         this._probeAgent(name).then(() => this._nodeHeartbeat()).catch(() => {});
+        this._askCliModels(name);
       } else if (action === 'start_agent') {
         const r = await this._runAgn(['start', name]);
         ok = r.code === 0;
@@ -673,7 +792,7 @@ async _runNodeCommand(n, cmd) {
           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,
+            'connect', name, '--workspace', n.workspace_slug || n.workspace_id, '--connection', n.node_id,
           ]);
           if (rc2.code !== 0) throw new Error(rc2.stderr || rc2.stdout || 'connect failed');
         } else {
@@ -689,6 +808,7 @@ async _runNodeCommand(n, cmd) {
         // A reconfigure changes credentials/model — re-verify in the
         // background so the workspace sees the new state without a manual test.
         this._probeAgent(name).then(() => this._nodeHeartbeat()).catch(() => {});
+        this._askCliModels(name);
       } else if (action === 'probe_agent') {
         // Smoke-test on demand ("Re-test" in the workspace). Probes belong to
         // configured agents (by name); the result rides agents[].probe.
@@ -805,11 +925,11 @@ async _runNodeCommand(n, cmd) {
       this._crashGuardsInstalled = true;
       process.on('unhandledRejection', (reason) => {
         const msg = reason && reason.stack ? reason.stack : String(reason);
-        this._log(`UNHANDLED REJECTION (daemon kept alive): ${msg}`);
+        this._log(`UNHANDLED REJECTION (daemon kept alive): ${msg}`, 'error');
       });
       process.on('uncaughtException', (err) => {
         const msg = err && err.stack ? err.stack : String(err);
-        this._log(`UNCAUGHT EXCEPTION (daemon kept alive): ${msg}`);
+        this._log(`UNCAUGHT EXCEPTION (daemon kept alive): ${msg}`, 'error');
       });
     }
 
@@ -877,6 +997,19 @@ async _runNodeCommand(n, cmd) {
       3600 * 1000,
     );
 
+    // What each signed-in agent's account is offered, for the workspace's
+    // model picker. Asking costs a CLI start and no model call. The pass is
+    // frequent so an agent added on the device is picked up soon; it only
+    // asks for a list that is missing or an hour old.
+    this._cliModelsStartupTimer = setTimeout(
+      () => this._refreshCliModels().catch(() => {}),
+      20 * 1000,
+    );
+    this._cliModelsInterval = setInterval(
+      () => this._refreshCliModels().catch(() => {}),
+      10 * 60 * 1000,
+    );
+
     // Watch config file for hot-reload
     this._watchConfig();
 
@@ -908,6 +1041,8 @@ async _runNodeCommand(n, cmd) {
     if (this._displayNameInterval) clearInterval(this._displayNameInterval);
     if (this._probeStartupTimer) clearTimeout(this._probeStartupTimer);
     if (this._probeInterval) clearInterval(this._probeInterval);
+    if (this._cliModelsStartupTimer) clearTimeout(this._cliModelsStartupTimer);
+    if (this._cliModelsInterval) clearInterval(this._cliModelsInterval);
     if (this._configWatcher) { try { this._configWatcher.close(); } catch {} }
 
     // Kill all child processes
@@ -919,6 +1054,7 @@ async _runNodeCommand(n, cmd) {
     this._writeStatus();
     this._cleanupPid();
     this._log('Daemon stopped');
+    if (this._logWriter) await this._logWriter.flush();
 
     if (this._shutdownResolve) this._shutdownResolve();
   }
@@ -947,7 +1083,7 @@ async _runNodeCommand(n, cmd) {
     // 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`);
+      this._log(`WARNING: ${agentName} adapter did not exit after stop — force-releasing slot`, 'warn');
       try { this._adapters[agentName].stop(); } catch {}
       delete this._adapters[agentName];
     }
@@ -1162,15 +1298,18 @@ async _runNodeCommand(n, cmd) {
    * fallback. Fields from the network entry win for display (name), the
    * pairing wins for credentials (token/endpoint).
    */
-  _resolveAgentNetwork(ref) {
+  _resolveAgentNetwork(ref, nodeId) {
     const network =
       this.config.getNetworks().find((n) => n.slug === ref || n.id === ref) ||
       null;
     let pairing = null;
     try {
-      pairing = require('./node-config')
-        .listPairings()
-        .find((p) => p.workspace_slug === ref || p.workspace_id === ref) || null;
+      const candidates = require('./node-config').listPairings()
+        .filter((p) => p.workspace_slug === ref || p.workspace_id === ref);
+      pairing = candidates.find((p) => !nodeId || p.node_id === nodeId) || null;
+      if ((nodeId && !pairing) || (!nodeId && candidates.length > 1)) {
+        return { ...(network || {}), token: null };
+      }
     } catch {}
     if (!network && !pairing) return null;
     return {
@@ -1214,7 +1353,7 @@ async _runNodeCommand(n, cmd) {
     // Workspace-connected agents use the adapter loop (poll + CLI per message).
     // Local-only agents use the spawn loop (long-running child process).
     const network = agentCfg.network
-      ? this._resolveAgentNetwork(agentCfg.network)
+      ? this._resolveAgentNetwork(agentCfg.network, agentCfg.node_id)
       : null;
 
     if (network && !network.token) {
@@ -1233,6 +1372,7 @@ async _runNodeCommand(n, cmd) {
       // Remember which credential this adapter runs with, so the rotation
       // watch can restart it when a re-pair hands the workspace a new token.
       info.networkRef = agentCfg.network;
+      info.connectionId = agentCfg.node_id;
       info.credentialToken = network.token;
       this._adapterLoop(name, agentCfg, info, network);
     } else {
@@ -1282,7 +1422,7 @@ async _runNodeCommand(n, cmd) {
         const exitCode = await new Promise((resolve) => {
           proc.on('exit', (code) => resolve(code));
           proc.on('error', (err) => {
-            this._log(`${name} spawn error: ${err.message}`);
+            this._log(`${name} spawn error: ${err.message}`, 'error');
             resolve(1);
           });
         });
@@ -1309,13 +1449,13 @@ async _runNodeCommand(n, cmd) {
         this._writeStatus();
 
         if (info.restarts >= 10) {
-          this._log(`${name} crashed ${info.restarts} times, giving up. Fix the issue and restart manually.`);
+          this._log(`${name} crashed ${info.restarts} times, giving up. Fix the issue and restart manually.`, 'error');
           info.state = 'stopped';
           this._writeStatus();
           break;
         }
 
-        this._log(`${name} crashed: ${info.lastError}, restarting in ${info._backoff}s (attempt ${info.restarts})`);
+        this._log(`${name} crashed: ${info.lastError}, restarting in ${info._backoff}s (attempt ${info.restarts})`, 'warn');
         await this._sleep(info._backoff * 1000);
         info._backoff = Math.min(info._backoff * 2, 60);
       }
@@ -1384,6 +1524,7 @@ async _runNodeCommand(n, cmd) {
         toolMode: agentCfg.tool_mode || 'skills',
         // Live runtime/connectivity status → daemon.status.json (Agents list/TUI).
         onStatus: (update) => this._applyAdapterStatus(name, info, update),
+        logSink: (level, msg) => this._logAs(`adapter [${name}]`, level, msg),
       });
     } catch (e) {
       // A construction failure (e.g. unknown agent type in this core) is a hard
@@ -1391,7 +1532,7 @@ async _runNodeCommand(n, cmd) {
       info.state = 'error';
       info.errorReason = 'adapter_crashed';
       info.lastError = redactDiagnostic(e.message || String(e));
-      this._log(`${name} failed to create ${agentType} adapter: ${info.lastError}`);
+      this._log(`${name} failed to create ${agentType} adapter: ${info.lastError}`, 'error');
       this._writeStatus();
       return;
     }
@@ -1408,11 +1549,11 @@ async _runNodeCommand(n, cmd) {
         info.errorReason = pf.reason || 'runtime_missing';
         info.lastError = redactDiagnostic(pf.message || 'runtime not available');
         this._writeStatus();
-        this._log(`${name} preflight failed (${info.errorReason}): ${info.lastError}`);
+        this._log(`${name} preflight failed (${info.errorReason}): ${info.lastError}`, 'warn');
         return;
       }
     } catch (e) {
-      this._log(`${name} preflight error (ignored, continuing): ${e.message}`);
+      this._log(`${name} preflight error (ignored, continuing): ${e.message}`, 'warn');
     }
 
     // Store adapter reference for stop and duplicate detection
@@ -1440,7 +1581,7 @@ async _runNodeCommand(n, cmd) {
     } catch (e) {
       info.errorReason = info.errorReason || 'adapter_crashed';
       info.lastError = redactDiagnostic((e.message || String(e)).slice(0, 200));
-      this._log(`${name} adapter error: ${info.lastError}`);
+      this._log(`${name} adapter error: ${info.lastError}`, 'error');
     }
 
     delete this._adapters[name];
@@ -1756,7 +1897,7 @@ async _runNodeCommand(n, cmd) {
     // The old adapter will exit on its next poll iteration since its
     // entry in _stoppedAgents triggers adapter.stop() via checkStop.
     if (this._adapters && this._adapters[name]) {
-      this._log(`WARNING: adapter '${name}' did not clear after 10s — force-releasing slot to avoid duplicate`);
+      this._log(`WARNING: adapter '${name}' did not clear after 10s — force-releasing slot to avoid duplicate`, 'warn');
       try { this._adapters[name].stop(); } catch {}
       delete this._adapters[name];
     }
@@ -1773,33 +1914,25 @@ async _runNodeCommand(n, cmd) {
     try { fs.unlinkSync(this.config.statusFile); } catch {}
   }
 
-  _log(msg) {
-    const ts = new Date().toISOString();
-    const line = `${ts} INFO daemon: ${msg}`;
-    try {
-      fs.appendFileSync(this.config.logFile, line + '\n', 'utf-8');
-      this._maybeRotateLog();
-    } catch {}
+  _log(msg, level = 'info') {
+    this._logAs('daemon', level, msg);
+  }
+
+  /**
+   * One entry in daemon.log. Adapters log through here too (see the `logSink`
+   * passed in _adapterLoop), so batching, repeat suppression and rotation cover
+   * their lines as well — they used to bypass all of it via console.log.
+   */
+  _logAs(scope, level, msg) {
+    if (!this._logWriter) this._logWriter = new LogWriter(this.config.logFile);
+    const written = this._logWriter.write(level, scope, msg);
     // Only log to console if stdout is a TTY (not redirected to log file)
     // to avoid duplicate lines when daemonized
-    if (!this._shuttingDown && process.stdout.isTTY) {
-      console.log(line);
+    if (written && !this._shuttingDown && process.stdout.isTTY) {
+      console.log(`${new Date().toISOString()} ${String(level).toUpperCase()} ${scope}: ${msg}`);
     }
   }
 
-  _maybeRotateLog() {
-    // Rotate at 10MB, keep 1 backup
-    const MAX_SIZE = 10 * 1024 * 1024;
-    try {
-      const stat = fs.statSync(this.config.logFile);
-      if (stat.size > MAX_SIZE) {
-        const backup = this.config.logFile + '.1';
-        try { fs.unlinkSync(backup); } catch {}
-        fs.renameSync(this.config.logFile, backup);
-      }
-    } catch {}
-  }
-
   _sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }

package/src/index.js

@@ -121,7 +121,7 @@ class AgentConnector {
     if (!network || !network.id) return null;
     const endpoint = network.endpoint || (this.workspace && this.workspace.endpoint);
     const { WorkspaceClient } = require('./workspace-client');
-    return { client: new WorkspaceClient(endpoint), network };
+    return { client: new WorkspaceClient(endpoint, { agentName }), network };
   }
 
   /**
@@ -431,6 +431,15 @@ class AgentConnector {
     const { probeAgentType } = require('./probe');
     return probeAgentType(this, agentType, opts);
   }
+
+  /**
+   * Ask an agent type's own CLI which models the account it is signed in to
+   * can run. See cli-models.js.
+   */
+  async listCliModels(agentType, opts) {
+    const { listCliModels } = require('./cli-models');
+    return listCliModels(this, agentType, opts);
+  }
 }
 
 const adapters = require('./adapters');