open-agents-ai 0.186.13 → 0.186.14

package/dist/index.js

@@ -7270,6 +7270,179 @@ async function handleCmd(cmd) {
         writeResp(id, { ok: true, output: 'pong' });
         break;
       }
+
+      // \u2500\u2500 NKN Backup Comms Layer \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+      // Persistent NKN addresses for fallback agent-to-agent communication.
+      // Each OA instance gets a deterministic NKN address derived from the
+      // mnemonic agent name. Messages are signed with HMAC to verify the
+      // AGENT sent them (not a human spoofing).
+
+      case 'nkn_status': {
+        var _nknIdFile = join(nexusDir, 'nkn-identity.json');
+        var _nknPeersFile = join(nexusDir, 'nkn-peers.json');
+        var _nknId = existsSync(_nknIdFile) ? JSON.parse(readFileSync(_nknIdFile, 'utf8')) : null;
+        var _nknPeers = existsSync(_nknPeersFile) ? JSON.parse(readFileSync(_nknPeersFile, 'utf8')) : { peers: [] };
+        var _nknConnected = nexus.nkn && nexus.nkn.isConnected;
+        writeResp(id, { ok: true, output: JSON.stringify({
+          enabled: !!nexus.nkn,
+          connected: _nknConnected,
+          address: _nknId ? _nknId.address : (nexus.nkn ? nexus.nkn.address : null),
+          publicKey: _nknId ? _nknId.publicKey : null,
+          peerCount: _nknPeers.peers ? _nknPeers.peers.length : 0,
+          libp2pPeerId: nexus.peerId || null,
+          agentName: agentName,
+        }) });
+        break;
+      }
+
+      case 'nkn_peers': {
+        // List all known NKN peer addresses (agents we've discovered)
+        var _npFile = join(nexusDir, 'nkn-peers.json');
+        var _npData = existsSync(_npFile) ? JSON.parse(readFileSync(_npFile, 'utf8')) : { peers: [] };
+        writeResp(id, { ok: true, output: JSON.stringify(_npData) });
+        break;
+      }
+
+      case 'nkn_inbox': {
+        // Read NKN inbox messages (most recent first, capped)
+        var _niDir = join(inboxDir, '_nkn');
+        var _niMessages = [];
+        try {
+          if (existsSync(_niDir)) {
+            var _niFiles = readdirSync(_niDir).filter(f => f.endsWith('.json')).sort().reverse().slice(0, 50);
+            for (var _niF of _niFiles) {
+              try { _niMessages.push(JSON.parse(readFileSync(join(_niDir, _niF), 'utf8'))); } catch {}
+            }
+          }
+        } catch {}
+        writeResp(id, { ok: true, output: JSON.stringify({ messages: _niMessages, count: _niMessages.length }) });
+        break;
+      }
+
+      case 'nkn_send': {
+        // Send a DM to another agent via NKN
+        // args: { to: "nkn-address", message: "text", verify: true }
+        var _nsTo = args.to || args.address;
+        var _nsMsg = args.message || args.content || '';
+        if (!_nsTo || !_nsMsg) {
+          writeResp(id, { ok: false, output: 'Required: to (NKN address) and message' });
+          break;
+        }
+        // Lazy NKN init
+        if (!nexus.nkn || !nexus.nkn.isConnected) {
+          try {
+            // Load or generate NKN seed from global identity
+            var _nsSeedFile = join(nexusDir, 'nkn-seed.hex');
+            var _nsSeed = undefined;
+            if (existsSync(_nsSeedFile)) {
+              _nsSeed = readFileSync(_nsSeedFile, 'utf8').trim();
+            } else {
+              // Derive NKN seed from agent name + identity key (deterministic)
+              var _nsKeyData = existsSync(keyPath) ? readFileSync(keyPath) : Buffer.from(agentName);
+              _nsSeed = createHash('sha256').update(_nsKeyData).update('nkn-seed-v1').digest('hex');
+              writeFileSync(_nsSeedFile, _nsSeed, { mode: 0o600 });
+            }
+            // Connect NKN via nexus client if available
+            if (nexus.nkn && typeof nexus.nkn.connect === 'function') {
+              await nexus.nkn.connect(_nsSeed);
+            } else {
+              // Direct NKN init if nexus client doesn't expose nkn
+              var nknSdk = await import('nkn-sdk');
+              var _nknMC = new nknSdk.default.MultiClient({ seed: _nsSeed, identifier: 'oa-' + agentName.replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 20), numSubClients: 3 });
+              await new Promise(function(resolve, reject) {
+                _nknMC.onConnect(resolve);
+                setTimeout(function() { reject(new Error('NKN connect timeout (15s)')); }, 15000);
+              });
+              // Store address
+              var _nsIdFile = join(nexusDir, 'nkn-identity.json');
+              writeFileSync(_nsIdFile, JSON.stringify({
+                address: _nknMC.addr,
+                publicKey: _nknMC.getPublicKey(),
+                agentName: agentName,
+                libp2pPeerId: nexus.peerId || null,
+                createdAt: new Date().toISOString(),
+              }, null, 2), { mode: 0o600 });
+              dlog('NKN connected: ' + _nknMC.addr);
+              // Receive handler \u2014 store in inbox
+              _nknMC.onMessage(function({ src, payload }) {
+                var _body = typeof payload === 'string' ? payload : new TextDecoder().decode(payload);
+                var _niDir2 = join(inboxDir, '_nkn');
+                mkdirSync(_niDir2, { recursive: true });
+                var _entry = { sender: src, raw: _body, receivedAt: Date.now(), verified: false };
+                // Verify HMAC if present
+                try {
+                  var _parsed = JSON.parse(_body);
+                  if (_parsed._hmac && _parsed._agentName && _parsed.content) {
+                    // Verify: HMAC(agentName + content + timestamp, shared_secret)
+                    var _sharedSecret = createHash('sha256').update(src).update(_nknMC.addr).update('oa-nkn-v1').digest('hex');
+                    var _expectedHmac = createHmac('sha256', _sharedSecret).update(_parsed._agentName + _parsed.content + String(_parsed.timestamp || 0)).digest('hex').slice(0, 16);
+                    _entry.verified = (_parsed._hmac === _expectedHmac);
+                    _entry.agentName = _parsed._agentName;
+                    _entry.content = _parsed.content;
+                    _entry.timestamp = _parsed.timestamp;
+                  }
+                } catch { /* raw text message \u2014 not verified */ }
+                try { writeFileSync(join(_niDir2, Date.now() + '.json'), JSON.stringify(_entry, null, 2)); } catch {}
+              });
+              // Stash the client for reuse
+              nexus._nknDirect = _nknMC;
+            }
+          } catch (nknErr) {
+            writeResp(id, { ok: false, output: 'NKN connect failed: ' + (nknErr.message || nknErr) });
+            break;
+          }
+        }
+        // Build verified message with HMAC
+        var _nsClient = nexus._nknDirect || (nexus.nkn && nexus.nkn.client);
+        if (!_nsClient) { writeResp(id, { ok: false, output: 'NKN not connected' }); break; }
+        var _nsMyAddr = _nsClient.addr || (nexus.nkn ? nexus.nkn.address : '');
+        var _nsTimestamp = Date.now();
+        var _nsSharedSecret = createHash('sha256').update(_nsMyAddr).update(_nsTo).update('oa-nkn-v1').digest('hex');
+        var _nsHmac = createHmac('sha256', _nsSharedSecret).update(agentName + _nsMsg + String(_nsTimestamp)).digest('hex').slice(0, 16);
+        var _nsEnvelope = JSON.stringify({
+          _agentName: agentName,
+          content: _nsMsg,
+          timestamp: _nsTimestamp,
+          libp2pPeerId: nexus.peerId || null,
+          _hmac: _nsHmac,
+        });
+        try {
+          await _nsClient.send(_nsTo, _nsEnvelope, { msgHoldingSeconds: 3600 });
+          // Add to peer list if not already there
+          var _nsPeersFile = join(nexusDir, 'nkn-peers.json');
+          var _nsPeers = existsSync(_nsPeersFile) ? JSON.parse(readFileSync(_nsPeersFile, 'utf8')) : { peers: [] };
+          if (!_nsPeers.peers.find(function(p) { return p.nknAddress === _nsTo; })) {
+            _nsPeers.peers.push({ nknAddress: _nsTo, lastContact: _nsTimestamp, agentName: args.to_agent || 'unknown' });
+            writeFileSync(_nsPeersFile, JSON.stringify(_nsPeers, null, 2));
+          }
+          writeResp(id, { ok: true, output: 'Sent to ' + _nsTo + ' (HMAC verified, held 1h if offline)' });
+        } catch (sendErr) {
+          writeResp(id, { ok: false, output: 'NKN send failed: ' + (sendErr.message || sendErr) });
+        }
+        break;
+      }
+
+      case 'nkn_add_peer': {
+        // Manually add a peer's NKN address to the address book
+        var _napAddr = args.nkn_address || args.address;
+        var _napName = args.agent_name || args.name || 'unknown';
+        var _napPeerId = args.libp2p_peer_id || args.peer_id || '';
+        if (!_napAddr) { writeResp(id, { ok: false, output: 'Required: nkn_address' }); break; }
+        var _napFile = join(nexusDir, 'nkn-peers.json');
+        var _napData = existsSync(_napFile) ? JSON.parse(readFileSync(_napFile, 'utf8')) : { peers: [] };
+        var _napExisting = _napData.peers.findIndex(function(p) { return p.nknAddress === _napAddr; });
+        if (_napExisting >= 0) {
+          _napData.peers[_napExisting].agentName = _napName;
+          _napData.peers[_napExisting].libp2pPeerId = _napPeerId || _napData.peers[_napExisting].libp2pPeerId;
+          _napData.peers[_napExisting].lastContact = Date.now();
+        } else {
+          _napData.peers.push({ nknAddress: _napAddr, agentName: _napName, libp2pPeerId: _napPeerId, addedAt: Date.now(), lastContact: Date.now() });
+        }
+        writeFileSync(_napFile, JSON.stringify(_napData, null, 2));
+        writeResp(id, { ok: true, output: 'Added peer: ' + _napName + ' (' + _napAddr.slice(0, 30) + '...)' });
+        break;
+      }
+
       default:
         writeResp(id, { ok: false, output: 'Unknown daemon command: ' + action });
     }
@@ -8218,9 +8391,14 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
               "ipfs_add",
               "ipfs_pin",
               "ipfs_ls",
-              "cohere_publish_insight"
+              "cohere_publish_insight",
+              "nkn_status",
+              "nkn_peers",
+              "nkn_inbox",
+              "nkn_send",
+              "nkn_add_peer"
             ],
-            description: "The nexus action. MUST call 'connect' first (spawns daemon). Then: join_room, send_message, discover_peers, expose, status, cohere_stats, cohere_enable, cohere_disable, cohere_allow_model, cohere_deny_model, cohere_list_models, ipfs_add, etc."
+            description: "The nexus action. MUST call 'connect' first (spawns daemon). Then: join_room, send_message, discover_peers, expose, status, nkn_status (NKN backup comms), nkn_peers (address book), nkn_inbox (read messages), nkn_send (DM via NKN with HMAC verification), nkn_add_peer (add to address book), cohere_stats, ipfs_add, etc."
           },
           room_id: {
             type: "string",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.186.13",
+  "version": "0.186.14",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",