@openagents-org/agent-launcher 0.2.190 → 0.2.191

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagents-org/agent-launcher",
-  "version": "0.2.190",
+  "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/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;
 

package/src/daemon.js

@@ -86,6 +86,15 @@ function _sentKey(args) {
   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;
@@ -206,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)));
   }
 
@@ -264,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`);

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,