@openagents-org/agent-launcher 0.2.153 → 0.2.155

package/package.json

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

package/src/cli.js

@@ -396,6 +396,83 @@ async function cmdConnect(connector, flags, positional) {
   }
 }
 
+async function cmdNode(connector, flags, positional) {
+  const sub = positional[0] || 'status';
+  const nodeCfg = require('./node-config');
+
+  if (sub === 'connect') {
+    const code = positional[1] || flags.code;
+    if (!code) {
+      print('Usage: agn node connect <pairing-code>');
+      print('Get a pairing code from your workspace: Connect a Node.');
+      process.exitCode = 1;
+      return;
+    }
+    const info = nodeCfg.gatherDeviceInfo();
+    if (flags.type) info.deviceType = flags.type;   // server | laptop | desktop
+    if (flags.name) info.name = flags.name;
+
+    print('Connecting this device to your workspace...');
+    try {
+      const res = await connector.redeemNodePairingCode(code, info);
+      nodeCfg.saveNode({
+        node_id: res.nodeId,
+        node_key: info.nodeKey,
+        workspace_id: res.workspaceId,
+        workspace_slug: res.workspaceSlug,
+        endpoint: connector.workspace.endpoint,
+        token: res.token,
+      });
+      // Register the workspace locally so agents created on this node can use it.
+      connector.config.addNetwork({
+        id: res.workspaceId,
+        slug: res.workspaceSlug,
+        name: res.workspaceName,
+        endpoint: connector.workspace.endpoint,
+        token: res.token,
+      });
+      print(`Node connected to workspace '${res.workspaceName}' (${res.workspaceSlug})`);
+      print(`  This device: ${info.hostname} (${info.deviceType})`);
+
+      // (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('  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();
+      print('');
+      print('Next: add an agent from the workspace, or run:');
+      print('  agn create <name> --type <type> --install');
+    } catch (e) {
+      print(`Error: ${e.message}`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  if (sub === 'status') {
+    const n = nodeCfg.loadNode();
+    if (n && n.node_id) {
+      print(`Node connected: ${n.node_id}`);
+      print(`  Workspace: ${n.workspace_slug || n.workspace_id}`);
+    } else {
+      print('No node connected. Run: agn node connect <pairing-code>');
+    }
+    return;
+  }
+
+  print('Usage: agn node <connect|status> [pairing-code]');
+  process.exitCode = 1;
+}
+
 async function cmdDisconnect(connector, _flags, positional) {
   const name = positional[0];
   if (!name) { print('Usage: agn disconnect <agent-name>'); return; }
@@ -705,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) {
@@ -725,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() {
@@ -830,6 +924,7 @@ async function main() {
     search: () => cmdSearch(connector, flags, positional),
     runtimes: () => cmdRuntimes(connector),
     connect: () => cmdConnect(connector, flags, positional),
+    node: () => cmdNode(connector, flags, positional),
     disconnect: () => cmdDisconnect(connector, flags, positional),
     logs: () => cmdLogs(connector, flags, positional),
     autostart: () => cmdAutostart(connector, flags),
@@ -838,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

@@ -30,9 +30,31 @@ class Daemon {
     this._shuttingDown = false;
     this._statusInterval = null;
     this._cmdInterval = null;
+    this._nodeHeartbeatInterval = null;  // device-level heartbeat (connect-a-node)
+    this._nodeClient = null;             // lazily-created WorkspaceClient for the node
     this._reloadInFlight = null;  // serialize concurrent _reload() calls
   }
 
+  /**
+   * Heartbeat this device (node) to its workspace, independent of any agent, so
+   * the workspace's "connected devices" view stays live even with zero agents.
+   * Best-effort: node liveness is non-critical to agent operation.
+   */
+  async _nodeHeartbeat() {
+    try {
+      const nodeCfg = require('./node-config');
+      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());
+    } catch {
+      // ignore — will retry next interval
+    }
+  }
+
   // ---------------------------------------------------------------------------
   // Public API
   // ---------------------------------------------------------------------------
@@ -91,6 +113,10 @@ class Daemon {
       this._processCommands();
     }, 200);
 
+    // Device-level heartbeat (connect-a-node), independent of agents.
+    this._nodeHeartbeat();
+    this._nodeHeartbeatInterval = setInterval(() => this._nodeHeartbeat(), 30000);
+
     // Watch config file for hot-reload
     this._watchConfig();
 
@@ -116,6 +142,7 @@ class Daemon {
 
     if (this._statusInterval) clearInterval(this._statusInterval);
     if (this._cmdInterval) clearInterval(this._cmdInterval);
+    if (this._nodeHeartbeatInterval) clearInterval(this._nodeHeartbeatInterval);
     if (this._configWatcher) { try { this._configWatcher.close(); } catch {} }
 
     // Kill all child processes

package/src/index.js

@@ -275,6 +275,10 @@ class AgentConnector {
     return this.workspace.resolveToken(token);
   }
 
+  async redeemNodePairingCode(code, deviceInfo) {
+    return this.workspace.redeemPairingCode(code, deviceInfo);
+  }
+
   // -- LLM test --
 
   async testLLM(env) {

package/src/node-config.js

@@ -0,0 +1,72 @@
+'use strict';
+
+/**
+ * Node identity for "connect a node" (~/.openagents/node.json).
+ *
+ * A node is this device's registration with a workspace, independent of any
+ * agent. Stores the stable device key, the assigned node id, and the workspace
+ * binding + token so the daemon can heartbeat the node.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+const NODE_DIR = path.join(os.homedir(), '.openagents');
+const NODE_FILE = path.join(NODE_DIR, 'node.json');
+
+function loadNode() {
+  try {
+    if (fs.existsSync(NODE_FILE)) return JSON.parse(fs.readFileSync(NODE_FILE, 'utf-8'));
+  } catch {}
+  return null;
+}
+
+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
+  } catch {}
+}
+
+/** Stable per-device id, generated once and persisted. */
+function getOrCreateNodeKey() {
+  const existing = loadNode();
+  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;
+}
+
+/** Best-effort device type from the platform (user/UI can override). */
+function inferDeviceType() {
+  const p = os.platform();
+  if (p === 'darwin') return 'laptop';
+  if (p === 'win32') return 'desktop';
+  return 'server';  // linux is typically a server/VM in this context
+}
+
+/** Device info sent on redeem/heartbeat. */
+function gatherDeviceInfo() {
+  let launcherVersion = '';
+  try { launcherVersion = require('../package.json').version; } catch {}
+  return {
+    nodeKey: getOrCreateNodeKey(),
+    hostname: os.hostname(),
+    os: os.platform(),
+    deviceType: inferDeviceType(),
+    launcherVersion,
+  };
+}
+
+module.exports = {
+  loadNode,
+  saveNode,
+  getOrCreateNodeKey,
+  inferDeviceType,
+  gatherDeviceInfo,
+  NODE_FILE,
+  NODE_DIR,
+};

package/src/workspace-client.js

@@ -107,6 +107,36 @@ class WorkspaceClient {
     return data.data || data;
   }
 
+  /**
+   * Redeem a node pairing code via POST /v1/nodes/redeem. The code is the
+   * credential (no auth header). Returns { nodeId, workspaceId, workspaceSlug,
+   * workspaceName, token } — the token is the workspace's machine credential.
+   */
+  async redeemPairingCode(code, deviceInfo = {}) {
+    const body = { code, node_key: deviceInfo.nodeKey };
+    if (deviceInfo.name) body.name = deviceInfo.name;
+    if (deviceInfo.hostname) body.hostname = deviceInfo.hostname;
+    if (deviceInfo.deviceType) body.device_type = deviceInfo.deviceType;
+    if (deviceInfo.os) body.os = deviceInfo.os;
+    if (deviceInfo.launcherVersion) body.launcher_version = deviceInfo.launcherVersion;
+    const data = await this._post('/v1/nodes/redeem', body);
+    return data.data || data;
+  }
+
+  /**
+   * Node liveness via POST /v1/nodes/heartbeat (authenticated by the workspace
+   * token). Independent of any agent heartbeat.
+   */
+  async nodeHeartbeat(nodeId, token, deviceInfo = {}) {
+    const body = { node_id: nodeId };
+    if (deviceInfo.hostname) body.hostname = deviceInfo.hostname;
+    if (deviceInfo.deviceType) body.device_type = deviceInfo.deviceType;
+    if (deviceInfo.os) body.os = deviceInfo.os;
+    if (deviceInfo.launcherVersion) body.launcher_version = deviceInfo.launcherVersion;
+    const data = await this._post('/v1/nodes/heartbeat', body, this._wsHeaders(token));
+    return data.data || data;
+  }
+
   /**
    * Send heartbeat via POST /v1/heartbeat.
    *