@openagents-org/agent-launcher 0.2.152 → 0.2.154

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagents-org/agent-launcher",
-  "version": "0.2.152",
+  "version": "0.2.154",
   "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,76 @@ 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})`);
+
+      // Start the daemon so the node heartbeats and agents can run.
+      if (connector.getDaemonPid()) {
+        print('  Daemon already running.');
+      } 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; }
@@ -830,6 +900,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),

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/installer.js

@@ -4,7 +4,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { execSync, exec } = require('child_process');
-const { whichBinary, getEnhancedEnv, getRuntimePrefix, clearBinaryLookupCache, aiderBinDirs } = require('./paths');
+const { whichBinary, getEnhancedEnv, getRuntimePrefix, clearBinaryLookupCache, aiderBinDirs, resolveBinaryInKnownDirs } = require('./paths');
 const { EnvManager } = require('./env');
 const { readinessReason, REASON } = require('./adapters/health-status');
 
@@ -394,6 +394,44 @@ class Installer {
     return found ? { path: found } : null;
   }
 
+  /**
+   * Confirm a real cursor-agent binary landed, for verify-before-mark.
+   *
+   * Cursor's Windows one-liner (`irm 'https://cursor.com/install?win32=true' |
+   * iex`) downloads the CLI with Invoke-WebRequest. When that download fails —
+   * an "unexpected EOF or 0 bytes" IOException is what users behind a filtering
+   * network get — PowerShell treats it as NON-terminating: the script carries
+   * on, prints "Start using Cursor Agent" and "Happy coding!", and exits 0. All
+   * that's left on disk is an empty %LOCALAPPDATA%\cursor-agent\versions\.
+   *
+   * Same defect hermes and amp already guard against here. Without this the
+   * marker gets written, the launcher reports Cursor installed, offers a
+   * sign-in, and the only way the user finds out is a terminal saying
+   * "'cursor-agent' is not recognized".
+   */
+  _verifyCursorBinary() {
+    try { clearBinaryLookupCache(); } catch {}
+    const resolved = this._whichBinary('cursor');
+    if (resolved && fs.existsSync(resolved)) return { path: resolved };
+    return null;
+  }
+
+  _cursorBinaryNotFoundMessage() {
+    const localAppData =
+      process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+    const isWin = process.platform === 'win32';
+    const expected = isWin
+      ? path.join(localAppData, 'cursor-agent')
+      : path.join(os.homedir(), '.local', 'bin', 'cursor-agent');
+    return (
+      'Cursor install command completed, but the cursor-agent binary could not be found\n' +
+      "(its installer prints \"Happy coding!\" and exits 0 even when the download failed —\n" +
+      'look for "unexpected EOF" or a network error in the log above).\n\n' +
+      `Expected under:\n${expected}\n\n` +
+      'Retry the install, or check that cursor.com is reachable from this network.'
+    );
+  }
+
   _hermesBinaryNotFoundMessage() {
     const isWin = process.platform === 'win32';
     const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
@@ -1066,6 +1104,18 @@ class Installer {
             }
             if (onData) onData(`\nHermes CLI resolved: ${hermes.path}\n`);
           }
+          // Cursor-only: same failure shape as hermes above — its installer
+          // exits 0 after a failed download. See _verifyCursorBinary.
+          if (agentType === 'cursor') {
+            const cursor = this._verifyCursorBinary();
+            if (!cursor) {
+              const msg = this._cursorBinaryNotFoundMessage();
+              if (onData) onData(`\n${msg}\n`);
+              reject(new Error(msg));
+              return;
+            }
+            if (onData) onData(`\nCursor CLI resolved: ${cursor.path}\n`);
+          }
           this._markInstalled(agentType);
           if (onData) onData(`\nDone! ${agentType} is now installed.\n`);
           resolve({ success: true, command: displayCmd });
@@ -1296,7 +1346,14 @@ class Installer {
     // runnable. Generic and backward-compatible — only runs after PATH misses.
     const pkgBin = this._resolvePackageBin(agentType, entry, binary);
     if (pkgBin) return pkgBin;
-    return null;
+    // Last: check the known install dirs on disk. A PATH lookup misses a CLI
+    // whose installer only edited the *registry* PATH (Cursor, Amp, Hermes on
+    // Windows) until the process restarts, and the launcher — which resolves
+    // through here — then reports a working install as missing and offers a
+    // terminal running a bare command that cannot resolve either. Each adapter
+    // already does this search; this puts it in the one place the launcher
+    // actually calls.
+    return resolveBinaryInKnownDirs([binary, ...aliases], agentType);
   }
 
   /**

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/paths.js

@@ -517,12 +517,69 @@ function aiderBinDirs() {
   return dirs;
 }
 
+/** Executable suffixes to try for a bare binary name, per platform. */
+const BIN_EXTS = IS_WINDOWS ? ['.cmd', '.exe', '.bat', ''] : [''];
+
+/**
+ * Last-resort binary lookup: walk the directories we already know agent CLIs
+ * land in and check the filesystem directly, instead of asking the shell.
+ *
+ * `where`/`which` is not enough on Windows. The Cursor, Amp and Hermes
+ * installers edit the *registry* PATH, which an already-running process never
+ * inherits — so a perfectly good install is invisible to a PATH lookup until
+ * the machine (or at least the app) is restarted. Every adapter grew its own
+ * tiered search to cope; the launcher had none, so it alone reported "can't
+ * find it" and then opened a terminal running a bare command that could only
+ * fail with "'cursor-agent' is not recognized".
+ *
+ * Deliberately reuses getExtraBinDirs() rather than a second hardcoded list:
+ * that list already IS the curated set, and a copy of it is exactly how the
+ * launcher and the adapters drifted apart in the first place.
+ *
+ * Runs only after a PATH lookup has already missed, so it can add resolutions
+ * but never change one that already works.
+ *
+ * @param {string|string[]} names  binary name(s), e.g. ['cursor-agent','agent']
+ * @param {string} [agentType]     adds that agent's isolated runtime bin dir
+ * @returns {string|null} absolute path, or null
+ */
+function resolveBinaryInKnownDirs(names, agentType) {
+  const list = (Array.isArray(names) ? names : [names]).filter(Boolean);
+  if (!list.length) return null;
+
+  const dirs = [];
+  const push = (d) => { if (d && !dirs.includes(d)) dirs.push(d); };
+
+  // The agent's own isolated runtime first — it is the copy this launcher
+  // installed, and should win over anything the user happens to have globally.
+  if (agentType) push(path.join(getRuntimePrefix(agentType), 'node_modules', '.bin'));
+  push(path.join(HOME, '.openagents', 'nodejs', 'node_modules', '.bin'));
+  try { push(path.dirname(process.execPath)); } catch {}
+  for (const d of getExtraBinDirs()) push(d);
+
+  for (const dir of dirs) {
+    for (const name of list) {
+      for (const ext of BIN_EXTS) {
+        const candidate = path.join(dir, `${name}${ext}`);
+        try {
+          if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
+        } catch {
+          /* unreadable path — keep looking */
+        }
+      }
+    }
+  }
+  return null;
+}
+
+
 module.exports = {
   getExtraBinDirs,
   getEnhancedPATH,
   getEnhancedEnv,
   whichBinary,
   whereBinary,
+  resolveBinaryInKnownDirs,
   clearBinaryLookupCache,
   getRuntimePrefix,
   getCorePrefix,

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.
    *