diodejs 0.4.3 → 0.4.4

package/bindPort.js

@@ -660,6 +660,46 @@ class BindPort {
         let rpc = null;
 
         let ref;
+        let clientClosed = false;
+        let remoteCleanupStarted = false;
+        let tlsSocketWrapper = null;
+
+        const closeRemoteRef = async () => {
+          if (remoteCleanupStarted) {
+            return;
+          }
+
+          if (!ref || !connection || !rpc) {
+            return;
+          }
+          remoteCleanupStarted = true;
+
+          const storedSocket = typeof connection.getClientSocket === 'function'
+            ? connection.getClientSocket(ref)
+            : null;
+          if (storedSocket && storedSocket !== clientSocket && typeof storedSocket.end === 'function') {
+            try { storedSocket.end(); } catch {}
+          }
+          if (typeof connection.deleteClientSocket === 'function') {
+            try { connection.deleteClientSocket(ref); } catch {}
+          }
+
+          try {
+            await rpc.portClose(ref);
+            logger.info(() => `Port closed on device for ref: ${ref.toString('hex')}`);
+          } catch (error) {
+            logger.error(() => `Error closing port on device: ${error}`);
+          }
+        };
+
+        clientSocket.once('close', () => {
+          clientClosed = true;
+          closeRemoteRef();
+        });
+        clientSocket.once('error', (err) => {
+          logger.error(() => `Client socket error: ${err}`);
+        });
+
         if (useNative) {
           try {
             connection = await this._resolveConnectionForDevice(deviceId);
@@ -783,6 +823,12 @@ class BindPort {
           return;
         }
 
+        if (clientClosed || clientSocket.destroyed) {
+          logger.warn(() => `Local client disconnected before port ${formattedTargetPort} opened; closing ref ${ref.toString('hex')}`);
+          await closeRemoteRef();
+          return;
+        }
+
         if (protocol === 'tls') {
           // For tls protocol, create a proper tls connection
           try {
@@ -829,16 +875,27 @@ class BindPort {
               diodeSocket,
               tlsSocket,
               end: () => {
-                tlsSocket.end();
-                diodeSocket._destroy(null, () => {});
+                try { tlsSocket.end(); } catch {}
+                try { diodeSocket._destroy(null, () => {}); } catch {}
               }
             };
+            tlsSocketWrapper = socketWrapper;
             
             // Store the socket wrapper
             connection.addClientSocket(ref, socketWrapper);
+            tlsSocket.once('close', () => {
+              if (!clientSocket.destroyed) {
+                clientSocket.end();
+              }
+              closeRemoteRef();
+            });
             
           } catch (error) {
             logger.error(() => `Error setting up tls connection: ${error}`);
+            if (tlsSocketWrapper && typeof tlsSocketWrapper.end === 'function') {
+              tlsSocketWrapper.end();
+            }
+            await closeRemoteRef();
             clientSocket.destroy();
             return;
           }
@@ -858,24 +915,9 @@ class BindPort {
         }
 
         // Handle client socket closure (common for all protocols)
-        clientSocket.on('end', async () => {
+        clientSocket.once('end', () => {
           logger.info(() => 'Client disconnected');
-          if (ref && connection.hasClientSocket(ref)) {
-            try {
-              await rpc.portClose(ref);
-              logger.info(() => `Port closed on device for ref: ${ref.toString('hex')}`);
-              connection.deleteClientSocket(ref);
-            } catch (error) {
-              logger.error(() => `Error closing port on device: ${error}`);
-            }
-          } else {
-            logger.warn(() => 'Ref is invalid or no longer in clientSockets.');
-          }
-        });
-
-        // Handle client socket errors
-        clientSocket.on('error', (err) => {
-          logger.error(() => `Client socket error: ${err}`);
+          closeRemoteRef();
         });
       });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diodejs",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "A JavaScript client for interacting with the Diode network. It provides functionalities to bind and publish ports, send RPC commands, and handle responses.",
   "main": "index.js",
   "scripts": {

package/test/bindPort.test.js

@@ -1,6 +1,8 @@
 const test = require('node:test');
 const assert = require('node:assert/strict');
 const EventEmitter = require('events');
+const net = require('net');
+const { once } = require('events');
 
 const BindPort = require('../bindPort');
 
@@ -9,21 +11,61 @@ function makeRef(hex) {
 }
 
 function makeRelay(hostKey, result, calls) {
+  const clientSockets = new Map();
+  const portCloseCalls = [];
   return {
     _managerHostKey: hostKey,
     socket: { destroyed: false },
+    clientSockets,
+    portCloseCalls,
     RPC: {
       portOpen: async (_deviceId, port, flags) => {
         calls.push({ hostKey, port, flags });
         if (result instanceof Error) {
           throw result;
         }
-        return result;
+        return typeof result === 'function' ? result() : result;
       },
+      portClose: async (ref) => {
+        portCloseCalls.push(ref);
+      },
+    },
+    addClientSocket(ref, socket) {
+      clientSockets.set(ref.toString('hex'), socket);
+    },
+    getClientSocket(ref) {
+      return clientSockets.get(ref.toString('hex'));
+    },
+    deleteClientSocket(ref) {
+      return clientSockets.delete(ref.toString('hex'));
+    },
+    hasClientSocket(ref) {
+      return clientSockets.has(ref.toString('hex'));
     },
   };
 }
 
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+async function waitFor(predicate, timeoutMs = 1000) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (predicate()) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  assert.equal(predicate(), true);
+}
+
 class FakeManager extends EventEmitter {
   constructor({ relays, resolvedRelay, nearestRelay, resolveError = null }) {
     super();
@@ -123,3 +165,78 @@ test('multiple BindPort instances share one manager listener set', () => {
   assert.equal(manager.listenerCount('end'), 1);
   assert.equal(manager.listenerCount('error'), 1);
 });
+
+test('API bind closes ref when local TCP client disconnects before portopen returns', async () => {
+  const calls = [];
+  const opened = deferred();
+  const ref = makeRef('0a0b0c0d');
+  const relay = makeRelay('relay.example:41046', () => opened.promise, calls);
+  const manager = new FakeManager({
+    relays: [relay],
+    resolvedRelay: relay,
+    nearestRelay: relay,
+  });
+
+  const bind = new BindPort(manager, {
+    0: {
+      targetPort: 8088,
+      deviceIdHex: '8a72468957504d50247a260deb0218d504dd091b',
+      protocol: 'tcp',
+    }
+  });
+  bind.addPort(0, 8088, '8a72468957504d50247a260deb0218d504dd091b', 'tcp');
+  const server = bind.servers.get(0);
+
+  try {
+    await once(server, 'listening');
+    const client = net.connect(server.address().port, '127.0.0.1');
+    await once(client, 'connect');
+    client.destroy();
+    await once(client, 'close');
+
+    opened.resolve(ref);
+    await waitFor(() => relay.portCloseCalls.length === 1);
+
+    assert.equal(relay.portCloseCalls[0].toString('hex'), ref.toString('hex'));
+    assert.equal(relay.hasClientSocket(ref), false);
+  } finally {
+    server.close();
+  }
+});
+
+test('API bind closes ref when local TCP client disconnects after portopen returns', async () => {
+  const calls = [];
+  const ref = makeRef('0e0f1011');
+  const relay = makeRelay('relay.example:41046', ref, calls);
+  const manager = new FakeManager({
+    relays: [relay],
+    resolvedRelay: relay,
+    nearestRelay: relay,
+  });
+
+  const bind = new BindPort(manager, {
+    0: {
+      targetPort: 8088,
+      deviceIdHex: '8a72468957504d50247a260deb0218d504dd091b',
+      protocol: 'tcp',
+    }
+  });
+  bind.addPort(0, 8088, '8a72468957504d50247a260deb0218d504dd091b', 'tcp');
+  const server = bind.servers.get(0);
+
+  try {
+    await once(server, 'listening');
+    const client = net.connect(server.address().port, '127.0.0.1');
+    await once(client, 'connect');
+    await waitFor(() => relay.hasClientSocket(ref));
+
+    client.end();
+    await once(client, 'close');
+    await waitFor(() => relay.portCloseCalls.length === 1);
+
+    assert.equal(relay.portCloseCalls[0].toString('hex'), ref.toString('hex'));
+    assert.equal(relay.hasClientSocket(ref), false);
+  } finally {
+    server.close();
+  }
+});