nervepay 1.2.6 → 1.3.0

package/bin/nervepay-cli.js

@@ -360,33 +360,55 @@ async function deviceNodePairing(options) {
     console.log(chalk.cyan('\n📡 Connecting to gateway...'));
     const WebSocket = (await import('ws')).default;
 
-    const ws = new WebSocket(wsUrl);
+    const ws = new WebSocket(wsUrl, { rejectUnauthorized: false });
     const timeoutMs = parseInt(options.timeout, 10) * 1000;
 
+    // Pre-compute crypto values before entering the WebSocket flow
+    // (avoids async gaps in the message handler that cause race conditions)
+    const { decodeBase58 } = await import('../dist/utils/crypto.js');
+    const pubKeyBytes = decodeBase58(publicKeyBase58);
+    const pubKeyB64 = Buffer.from(pubKeyBytes).toString('base64');
+
     const result = await new Promise((resolve, reject) => {
+      let settled = false;
       let connectId = null;
       let pairId = null;
       let requestId = null;
+      let lastError = null;
+
+      function settle(fn, value) {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        fn(value);
+      }
+
       const timer = setTimeout(() => {
         ws.close();
-        reject(new Error(`Pairing approval timed out (waited ${options.timeout}s)`));
-      }, timeoutMs + 15000); // Extra buffer for handshake
+        settle(reject, new Error(`Pairing approval timed out (waited ${options.timeout}s)`));
+      }, timeoutMs + 15000);
 
       ws.on('error', (err) => {
-        clearTimeout(timer);
-        reject(new Error(`WebSocket error: ${err.message}`));
+        settle(reject, new Error(`WebSocket error: ${err.message}`));
       });
 
-      ws.on('close', () => {
-        clearTimeout(timer);
-        if (!requestId) {
-          reject(new Error('Gateway closed connection before pairing completed'));
-        }
+      ws.on('close', (code, reason) => {
+        // Delay slightly to let any pending message handler finish
+        setTimeout(() => {
+          const reasonStr = reason?.toString() || '';
+          const detail = lastError
+            ? lastError
+            : reasonStr
+              ? `code=${code} reason=${reasonStr}`
+              : `code=${code}`;
+          settle(reject, new Error(`Gateway closed connection (${detail})`));
+        }, 100);
       });
 
       ws.on('message', async (data) => {
         try {
-          const frame = JSON.parse(data.toString());
+          const raw = data.toString();
+          const frame = JSON.parse(raw);
 
           // Step 5: Receive connect.challenge → sign nonce
           if (frame.event === 'connect.challenge') {
@@ -397,15 +419,10 @@ async function deviceNodePairing(options) {
             const signatureB64 = await signRawBytes(privateKey, nonceBytes);
             const signedAt = Date.now();
 
-            // Encode public key as base64 for the gateway
-            const { decodeBase58 } = await import('../dist/utils/crypto.js');
-            const pubKeyBytes = decodeBase58(publicKeyBase58);
-            const pubKeyB64 = Buffer.from(pubKeyBytes).toString('base64');
-
             // Step 6: Send connect request as operator with device identity
             connectId = crypto.randomUUID();
             const connectReq = {
-              type: 'request',
+              type: 'req',
               id: connectId,
               method: 'connect',
               params: {
@@ -413,7 +430,7 @@ async function deviceNodePairing(options) {
                 scopes: ['operator.read', 'operator.write'],
                 client: {
                   id: `nervepay-cli-${crypto.randomUUID().slice(0, 8)}`,
-                  version: '1.2.1',
+                  version: '1.2.6',
                   platform: 'cli',
                   mode: 'pairing',
                 },
@@ -431,14 +448,14 @@ async function deviceNodePairing(options) {
           }
 
           // Connect response
-          if (frame.type === 'response' && frame.id === connectId) {
+          if (frame.type === 'res' && frame.id === connectId) {
             if (frame.ok) {
               console.log(chalk.green('✓ Connected to gateway'));
 
               // Step 7: Send node.pair.request
               pairId = crypto.randomUUID();
               const pairReq = {
-                type: 'request',
+                type: 'req',
                 id: pairId,
                 method: 'node.pair.request',
                 params: {
@@ -448,25 +465,27 @@ async function deviceNodePairing(options) {
               };
               ws.send(JSON.stringify(pairReq));
             } else {
-              clearTimeout(timer);
+              lastError = `Connect rejected: ${frame.error || 'Unknown error'}`;
+              console.error(chalk.red(`  ${lastError}`));
               ws.close();
-              reject(new Error(`Connect rejected: ${frame.error || 'Unknown error'}`));
+              settle(reject, new Error(lastError));
             }
             return;
           }
 
           // Pair request response → extract requestId
-          if (frame.type === 'response' && frame.id === pairId) {
+          if (frame.type === 'res' && frame.id === pairId) {
             if (frame.ok) {
               requestId = frame.payload?.requestId || '';
               console.log(chalk.green('✓ Pairing request submitted'));
               console.log(chalk.cyan('\n⏳ Waiting for gateway owner approval...'));
-              console.log(chalk.gray(`   Approve with: openclaw devices approve`));
+              console.log(chalk.gray(`   Approve with: openclaw devices approve ${requestId}`));
               console.log(chalk.gray(`   Timeout: ${options.timeout}s\n`));
             } else {
-              clearTimeout(timer);
+              lastError = `Pair request rejected: ${frame.error || 'Unknown error'}`;
+              console.error(chalk.red(`  ${lastError}`));
               ws.close();
-              reject(new Error(`Pair request rejected: ${frame.error || 'Unknown error'}`));
+              settle(reject, new Error(lastError));
             }
             return;
           }
@@ -474,26 +493,28 @@ async function deviceNodePairing(options) {
           // Step 8: node.pair.resolved event
           if (frame.event === 'node.pair.resolved') {
             const rid = frame.payload?.requestId;
-            if (rid && rid !== requestId) return; // Not our request
+            if (rid && rid !== requestId) return;
 
             const decision = frame.payload?.decision;
             if (decision === 'approved') {
-              clearTimeout(timer);
               const token = frame.payload?.token || '';
               const nodeId = frame.payload?.nodeId || '';
               ws.close();
-              resolve({ token, nodeId, requestId });
+              settle(resolve, { token, nodeId, requestId });
             } else if (decision === 'rejected') {
-              clearTimeout(timer);
               ws.close();
-              reject(new Error('Pairing request was rejected by the gateway owner'));
+              settle(reject, new Error('Pairing request was rejected by the gateway owner'));
             } else {
-              clearTimeout(timer);
               ws.close();
-              reject(new Error(`Unexpected pairing decision: ${decision}`));
+              settle(reject, new Error(`Unexpected pairing decision: ${decision}`));
             }
             return;
           }
+
+          // Log unhandled frames for debugging
+          if (frame.type === 'res' || frame.error) {
+            console.log(chalk.gray('  [debug] Unhandled frame:'), JSON.stringify(frame).slice(0, 200));
+          }
         } catch (err) {
           // Ignore parse errors for non-JSON messages (ping, etc)
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nervepay",
-  "version": "1.2.6",
+  "version": "1.3.0",
   "description": "NervePay plugin for OpenClaw - Self-sovereign identity, vault, and orchestration",
   "type": "module",
   "main": "dist/index.js",