@openagents-org/agent-launcher 0.2.154 → 0.2.156

package/package.json

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

package/src/cli.js

@@ -434,13 +434,20 @@ async function cmdNode(connector, flags, positional) {
       print(`Node connected to workspace '${res.workspaceName}' (${res.workspaceSlug})`);
       print(`  This device: ${info.hostname} (${info.deviceType})`);
 
-      // Start the daemon so the node heartbeats and agents can run.
+      // (Re)start the daemon so it runs the CURRENT launcher build and loads
+      // the new node identity. A daemon started before the connect-a-node
+      // feature has no node-heartbeat loop, so reusing it would leave the node
+      // showing offline — recycle it rather than reuse it.
       if (connector.getDaemonPid()) {
-        print('  Daemon already running.');
+        print('  Restarting daemon...');
+        connector.stopDaemon();
+        for (let i = 0; i < 25 && connector.getDaemonPid(); i++) {
+          await new Promise((resolve) => setTimeout(resolve, 200));
+        }
       } else {
         print('  Starting daemon...');
-        connector.startDaemon();
       }
+      connector.startDaemon();
       print('');
       print('Next: add an agent from the workspace, or run:');
       print('  agn create <name> --type <type> --install');
@@ -775,7 +782,7 @@ async function cmdVersion() {
   print(`${pkg.name} v${pkg.version}`);
 }
 
-async function cmdUpdate() {
+async function cmdUpdate(connector) {
   const { checkForUpdate, runUpdate, currentVersion } = require('./update-check');
   const info = await checkForUpdate();
   if (!info) {
@@ -795,6 +802,23 @@ async function cmdUpdate() {
     return;
   }
   print(`Updated to ${info.latest}.`);
+
+  // Recycle a running daemon so the new build takes effect immediately. Without
+  // this, a long-lived daemon keeps executing the OLD in-memory code (and misses
+  // new features) until the next manual restart or reboot — the failure mode
+  // that left a connected node showing offline after its launcher was upgraded.
+  try {
+    if (connector && connector.getDaemonPid()) {
+      print('Restarting daemon to apply the update...');
+      connector.stopDaemon();
+      for (let i = 0; i < 25 && connector.getDaemonPid(); i++) {
+        await new Promise((resolve) => setTimeout(resolve, 200));
+      }
+      connector.startDaemon();
+    }
+  } catch (e) {
+    print(`Note: could not restart the daemon automatically (${e.message}). Run 'agn restart'.`);
+  }
 }
 
 async function cmdHelp() {
@@ -909,7 +933,7 @@ async function main() {
     skills: () => cmdSkills(connector, flags, positional),
     'tool-mode': () => cmdToolMode(connector, flags, positional),
     'test-llm': () => cmdTestLLM(connector, flags, positional),
-    update: () => cmdUpdate(),
+    update: () => cmdUpdate(connector),
     'mcp-server': () => {
       const { runMcpServer } = require('./mcp-server');
       const workspaceId = flags['workspace-id'] || process.env.OPENAGENTS_WORKSPACE_ID;

package/src/daemon.js

@@ -32,6 +32,7 @@ class Daemon {
     this._cmdInterval = null;
     this._nodeHeartbeatInterval = null;  // device-level heartbeat (connect-a-node)
     this._nodeClient = null;             // lazily-created WorkspaceClient for the node
+    this._runningCommands = new Set();   // node-command ids currently executing
     this._reloadInFlight = null;  // serialize concurrent _reload() calls
   }
 
@@ -46,15 +47,116 @@ class Daemon {
       const n = nodeCfg.loadNode();
       if (!n || !n.node_id || !n.token) return;  // no node connected
       if (!this._nodeClient) {
-        const { WorkspaceClient } = require('./workspace-client');
         this._nodeClient = new WorkspaceClient(n.endpoint);
       }
-      await this._nodeClient.nodeHeartbeat(n.node_id, n.token, nodeCfg.gatherDeviceInfo());
+      const info = { ...nodeCfg.gatherDeviceInfo(), agents: this._buildRoster() };
+      const resp = await this._nodeClient.nodeHeartbeat(n.node_id, n.token, info);
+      // The heartbeat response is our push channel: run any queued remote
+      // agent-management commands the workspace enqueued for this node. Fire
+      // them off without blocking the heartbeat loop (an install can take
+      // minutes — awaiting here would stall liveness and stack up commands).
+      const commands = (resp && resp.commands) || [];
+      for (const cmd of commands) {
+        const id = cmd.commandId;
+        if (!id || this._runningCommands.has(id)) continue;
+        this._runningCommands.add(id);
+        this._runNodeCommand(n, cmd).finally(() => this._runningCommands.delete(id));
+      }
     } catch {
       // ignore — will retry next interval
     }
   }
 
+  /** Roster of agents this node hosts, for the workspace's node view. */
+  _buildRoster() {
+    const roster = [];
+    try {
+      const status = this.getStatus();
+      for (const [name, info] of Object.entries(status)) {
+        roster.push({ name, type: info.type || 'unknown', status: info.state || 'unknown' });
+      }
+    } catch {
+      // best-effort
+    }
+    return roster;
+  }
+
+  /**
+   * Execute one remote command by shelling out to this same launcher's CLI, so
+   * all of create/install/connect/start/stop/remove reuses the exact code path a
+   * local `agn` invocation would — then report the outcome back to the workspace.
+   */
+  async _runNodeCommand(n, cmd) {
+    const action = cmd.action;
+    const args = cmd.args || {};
+    const name = (args.name || '').trim();
+    let ok = false;
+    let message = '';
+    try {
+      if (action === 'create_agent') {
+        const type = (args.type || '').trim();
+        const r1 = await this._runAgn(['create', name, '--type', type, '--install']);
+        if (r1.code !== 0) throw new Error(r1.stderr || r1.stdout || 'create failed');
+        // 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.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]);
+        if (r2.code !== 0) throw new Error(r2.stderr || r2.stdout || 'connect failed');
+        ok = true;
+        message = `Agent '${name}' created`;
+      } else if (action === 'start_agent') {
+        const r = await this._runAgn(['start', name]);
+        ok = r.code === 0;
+        message = ok ? `Agent '${name}' started` : (r.stderr || r.stdout || 'start failed');
+      } else if (action === 'stop_agent') {
+        const r = await this._runAgn(['stop', name]);
+        ok = r.code === 0;
+        message = ok ? `Agent '${name}' stopped` : (r.stderr || r.stdout || 'stop failed');
+      } else if (action === 'remove_agent') {
+        const r = await this._runAgn(['remove', name]);
+        ok = r.code === 0;
+        message = ok ? `Agent '${name}' removed` : (r.stderr || r.stdout || 'remove failed');
+      } else {
+        message = `Unknown action '${action}'`;
+      }
+    } catch (e) {
+      ok = false;
+      message = e.message || String(e);
+    }
+    try {
+      await this._nodeClient.nodeCommandResult(cmd.commandId, n.token, { ok, message });
+    } catch {
+      // best-effort; the command stays 'running' if we can't report back
+    }
+  }
+
+  /** Run this launcher's own CLI as a child process, capturing output. */
+  _runAgn(cliArgs) {
+    return new Promise((resolve) => {
+      let bin;
+      try {
+        bin = require.resolve('../bin/agent-connector.js');
+      } catch {
+        bin = process.argv[1];
+      }
+      const child = spawn(process.execPath, [bin, ...cliArgs], {
+        env: { ...getEnhancedEnv(), OPENAGENTS_SKIP_UPDATE_CHECK: '1' },
+        // Run from home so a created agent's default working dir is sensible
+        // (not the ~/.openagents config dir).
+        cwd: os.homedir(),
+      });
+      let stdout = '';
+      let stderr = '';
+      child.stdout.on('data', (d) => { stdout += d.toString(); });
+      child.stderr.on('data', (d) => { stderr += d.toString(); });
+      child.on('error', (e) => resolve({ code: 1, stdout, stderr: stderr || e.message }));
+      child.on('close', (code) => resolve({ code, stdout, stderr }));
+    });
+  }
+
   // ---------------------------------------------------------------------------
   // Public API
   // ---------------------------------------------------------------------------
@@ -113,9 +215,11 @@ class Daemon {
       this._processCommands();
     }, 200);
 
-    // Device-level heartbeat (connect-a-node), independent of agents.
+    // Device-level heartbeat (connect-a-node), independent of agents. Also the
+    // delivery channel for remote agent-management commands, so keep it brisk
+    // (10s) — the request is tiny and it bounds remote-command pickup latency.
     this._nodeHeartbeat();
-    this._nodeHeartbeatInterval = setInterval(() => this._nodeHeartbeat(), 30000);
+    this._nodeHeartbeatInterval = setInterval(() => this._nodeHeartbeat(), 10000);
 
     // Watch config file for hot-reload
     this._watchConfig();

package/src/workspace-client.js

@@ -133,10 +133,24 @@ class WorkspaceClient {
     if (deviceInfo.deviceType) body.device_type = deviceInfo.deviceType;
     if (deviceInfo.os) body.os = deviceInfo.os;
     if (deviceInfo.launcherVersion) body.launcher_version = deviceInfo.launcherVersion;
+    if (Array.isArray(deviceInfo.agents)) body.agents = deviceInfo.agents;
     const data = await this._post('/v1/nodes/heartbeat', body, this._wsHeaders(token));
     return data.data || data;
   }
 
+  /**
+   * Report the outcome of a remote node command via
+   * POST /v1/nodes/commands/{id}/result (authenticated by the workspace token).
+   */
+  async nodeCommandResult(commandId, token, { ok, message } = {}) {
+    const data = await this._post(
+      `/v1/nodes/commands/${commandId}/result`,
+      { ok: !!ok, message: message || null },
+      this._wsHeaders(token),
+    );
+    return data.data || data;
+  }
+
   /**
    * Send heartbeat via POST /v1/heartbeat.
    *