homebridge-smartsystem 6.8.3 → 6.8.4

package/config.json

@@ -461,11 +461,11 @@
   "p1": false,
   "proxy": {
     "cloudServer": "ws.duotecno.eu",
-    "cloudPort": 5098,
+    "cloudPort": 5097,
     "masterAddress": "192.168.0.97",
     "masterPort": 5001,
     "uniqueId": "",
     "debug": false,
-    "kind": "solo"
+    "kind": "gw"
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "homebridge-smartsystem",
   "displayname": "Duotecno Bridge",
-  "version": "6.8.3",
+  "version": "6.8.4",
   "description": "SmartServer (Proxy Websockets to TCP sockets, Smappee MQTT, Duotecno IP Nodes, Homekit interface)",
   "main": "index.js",
   "author": "Johan Coppieters",

package/server/proxy.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = exports.cleanStart = exports.makeNewCloudConnection = exports.setProxyConfig = exports.kEmptyProxy = void 0;
 const net = require("net");
-const WebSocket = require("ws");
 const child_process_1 = require("child_process");
 const process_1 = require("process");
 exports.kEmptyProxy = {
@@ -61,17 +60,23 @@ function error(str) {
 ///////////////////////////////
 // Start up the proxy server //
 ///////////////////////////////
-// if (config.kind != "gw") {
-//   makeNewCloudConnection(config.masterAddress, config.masterPort, config.cloudServer, config.cloudPort, config.uniqueId);
-// }
+if (config.uniqueId) {
+    makeNewCloudConnection(config.masterAddress, config.masterPort, config.cloudServer, config.cloudPort, config.uniqueId);
+}
 function makeNewCloudConnection(master, masterPort, server, serverPort, uniqueId) {
-    const cloudSocket = new WebSocket('ws://' + server + ':' + serverPort + "/" + uniqueId);
-    cloudSocket.on('open', () => {
+    const cloudSocket = new net.Socket();
+    cloudSocket.connect(serverPort, server, () => {
         log(`[PROXY] → [CLOUD] Connected to Cloud at ${server}:${serverPort}`);
+        // Send unique ID as the first message to identify this proxy/device
+        cloudSocket.write(`[${uniqueId}]`);
+        debug(`[PROXY] → [CLOUD] Sent unique ID: ${uniqueId}`);
         const context = new Context(cloudSocket, master, masterPort, server, serverPort, uniqueId);
         gCloudConnections.push(context);
         log(`[PROXY] → [CLOUD] New free connection #${gCloudConnections.length} to the Cloud at ${server}:${serverPort}`);
     });
+    cloudSocket.on('error', (err) => {
+        error(`[PROXY] → [CLOUD] Failed to connect to Cloud: ${err.message}`);
+    });
     log(`[PROXY] → [CLOUD] Attempting to start a new free connection for ${config.uniqueId} to the Cloud at ${server}:${serverPort}`);
 }
 exports.makeNewCloudConnection = makeNewCloudConnection;
@@ -85,7 +90,7 @@ function cleanStart(restart = false) {
                 context.deviceSocket.end();
                 context.deviceSocket = null;
             }
-            context.cloudSocket.close();
+            context.cloudSocket.end();
             context.cloudSocket = null;
         });
         gCloudConnections.splice(0, gCloudConnections.length); // clear the array
@@ -117,11 +122,11 @@ class Context {
     }
     setupCloudSocket() {
         // set up handlers for the cloud socket
-        this.cloudSocket.on('message', message => {
-            this.handleDataFromCloud(message);
+        this.cloudSocket.on('data', data => {
+            this.handleDataFromCloud(data);
         });
-        this.cloudSocket.on('close', (code, reason) => {
-            warning('[CLOUD] Connection closed: ' + code + ' ' + reason);
+        this.cloudSocket.on('close', () => {
+            warning('[CLOUD] Connection closed');
             if (this.deviceSocket) {
                 this.deviceSocket.end();
                 this.deviceSocket = null;
@@ -136,26 +141,31 @@ class Context {
         });
     }
     handleDataFromCloud(data) {
-        debug(`[CLOUD] → [PROXY]: Data from Cloud: ${data.toString().slice(0, -1)}`);
+        debug(`[CLOUD] → [PROXY]: Data from Cloud: ${data.toString()}`);
         if (!this.deviceSocket) {
             // we either have a real client that wants to connect to the device,
             // or we receive a heartbeat from the cloud server
+            // or we receive a connection response [OK], [OK-=2], [ERROR-...]
             if (this.isHeartbeatRequest(data)) {
                 debug(`[CLOUD] → [PROXY]: Received heartbeat from Cloud, returning response.`);
                 // respond to the heartbeat of the cloud server
-                this.cloudSocket.send("[72,3]"); // command([Command.HeartbeatStatus, CommandMethod.Heartbeat.server])
+                this.cloudSocket.write("[72,3]"); // command([Command.HeartbeatStatus, CommandMethod.Heartbeat.server])
+            }
+            else if (this.isConnectionResponse(data)) {
+                debug(`[CLOUD] → [PROXY]: Received connection response from Cloud: ${data.toString()}`);
+                // Handle connection response from the cloud server
             }
             else {
-                // There is incomming data, it's a fresh connection, so: a new client wants to connect to the device
+                // There is real incomming data, it's a fresh connection, so: a new client wants to connect to the device
                 // 1) create a new (free) connection to the cloud server for the next client
                 // 2) connect to the device and send the initial data
-                log(`[PROXY] → [CLOUD] New client connection, creating new free connection for this proxy/device: ${this.uniqueId}.`);
+                log(`[PROXY] → [CLOUD] New client connection, creating new free connection for this proxy/device: ${config.uniqueId}.`);
                 makeNewCloudConnection(this.master, this.masterPort, this.server, this.serverPort, this.uniqueId);
                 this.makeDeviceConnection(this.master, this.masterPort, data);
             }
         }
         else if (this.deviceSocket.readyState === 'open') {
-            this.deviceSocket.write(data);
+            this.deviceSocket.write(new Uint8Array(data));
             debug(`[PROXY] → [DEVICE] forwarding data to device: ${data.toString().slice(0, -1)}`);
         }
         else {
@@ -168,25 +178,34 @@ class Context {
             this.deviceSocket = new net.Socket();
             // Connect to local device and send the data that came in from the cloud
             this.deviceSocket.connect(port, address, () => {
+                // Check if socket is still valid (not cleaned up by removeConnection)
+                if (!this.deviceSocket) {
+                    warning(`[PROXY] → [DEVICE] Device socket was cleaned up before connection completed`);
+                    return;
+                }
                 log(`[PROXY] → [DEVICE] Connected to local device at ${address}:${port}`);
                 this.setUpDeviceSocket();
                 log(`[PROXY] → [DEVICE] Sending initial message: ${data.toString().slice(0, -1)}`);
-                this.deviceSocket.write(data);
+                this.deviceSocket.write(new Uint8Array(data));
             });
         }
         else if (this.deviceSocket.readyState === 'open') {
             warning(`[PROXY] → [DEVICE] Device socket already open, sending data directly -- STRANGE !!`);
-            this.deviceSocket.write(data);
+            this.deviceSocket.write(new Uint8Array(data));
         }
         else {
             error(`[PROXY] → [DEVICE] Device socket exists, but is not open yet !!`);
         }
     }
     setUpDeviceSocket() {
+        if (!this.deviceSocket) {
+            error(`[PROXY] → [DEVICE] Cannot set up device socket - socket is null`);
+            return;
+        }
         this.deviceSocket.on('data', (data) => {
             const message = data.toString('utf-8');
             debug(`[DEVICE] → [PROXY] forwarding data to Cloud: ${message.slice(0, -1)}`);
-            this.cloudSocket.send(message);
+            this.cloudSocket.write(message);
         });
         this.deviceSocket.on('close', () => {
             log(`[DEVICE] → [PROXY] Device socket closed`);
@@ -198,11 +217,17 @@ class Context {
         });
     }
     removeConnection() {
-        this.deviceSocket = null;
+        // Clean up device socket
+        if (this.deviceSocket) {
+            if (!this.deviceSocket.destroyed) {
+                this.deviceSocket.end();
+            }
+            this.deviceSocket = null;
+        }
         // remove this context and close the cloud socket
         const index = gCloudConnections.indexOf(this);
         if (index !== -1) {
-            this.cloudSocket.close();
+            this.cloudSocket.end();
             this.cloudSocket = null;
             gCloudConnections.splice(index, 1);
             log(`[PROXY] → [CLOUD] Closed socket to Cloud and removed context for device ${this.master}`);
@@ -238,19 +263,20 @@ class Context {
     }
     // check if it's a heartbeat request from the server
     isHeartbeatRequest(data) {
-        // heartbeatKind = (poll = 1, poll_old = 2, serve = 3)
-        if (typeof data === 'string') {
-            return data === "[215,3]";
-        }
-        else {
-            return ((data[0] === 91) && // [
-                (data[1] === 50) && // 2
-                (data[2] === 49) && // 1
-                (data[3] === 53) && // 5
-                (data[4] === 44) && // ,
-                (data[5] === 51) && // 3
-                (data[6] === 93)); // ]
-        }
+        // hearbeatKind = (poll = 1, poll_old = 2, serve = 3)
+        return ((data[0] === 91) && // [
+            (data[1] === 50) && // 2
+            (data[2] === 49) && // 1
+            (data[3] === 53) && // 5
+            (data[4] === 44) && // ,
+            (data[5] === 51) && // 3
+            (data[6] === 93)); // ]
+    }
+    // check if it's a server response after connecting and sending our uniqueID
+    isConnectionResponse(data) {
+        const message = data.toString();
+        // Check for various server response patterns
+        return (message.startsWith('[OK')) || (message.startsWith('[ERROR'));
     }
 }
 exports.Context = Context;

package/server/proxy.ts

@@ -1,10 +1,9 @@
 import * as net from 'net';
-import * as WebSocket from 'ws';
 import { spawn } from 'child_process';
 import { argv, cwd, execPath } from 'process';
 
 //
-// [ device (TCP) ] ←→ [ Proxy = WebSocket client (ws) ] ←→ [ Cloud = 2 x WebSocket server (ws) ] ←→ [ browser client ]
+// [ device (TCP) ] ←→ [ Proxy = TCP client ] ←→ [ Cloud = TCP server ] ←→ [ browser client ]
 //
 
 export interface ProxyConfig {
@@ -16,6 +15,7 @@ export interface ProxyConfig {
   debug?: boolean;       // debug mode
   kind?: "pm2" | "gw" | "solo"; 
 }
+
 export const kEmptyProxy: ProxyConfig = {
   cloudServer: "ws.duotecno.eu",
   cloudPort: 5098,
@@ -50,6 +50,8 @@ try {
   console.log("No config-proxy.json found, using default values from homebridge or other.");
 }
 
+
+
 const gCloudConnections: Array<Context> = [];
 const kDebug = config.debug || false; // enable debug mode from config
 
@@ -75,26 +77,34 @@ function error(str: string) {
 ///////////////////////////////
 // Start up the proxy server //
 ///////////////////////////////
-
-// if (config.kind != "gw") {
-//   makeNewCloudConnection(config.masterAddress, config.masterPort, config.cloudServer, config.cloudPort, config.uniqueId);
-// }
+if (config.uniqueId) {
+  makeNewCloudConnection(config.masterAddress, config.masterPort, config.cloudServer, config.cloudPort, config.uniqueId);
+}
 
 
 export function makeNewCloudConnection(master: string, masterPort: number, server: string, serverPort: number, uniqueId: string) {
-  const cloudSocket = new WebSocket('ws://'+server+':'+serverPort+"/"+uniqueId);
-
-  cloudSocket.on('open', ()  => {
+  const cloudSocket = new net.Socket();
+  
+  cloudSocket.connect(serverPort, server, () => {
     log(`[PROXY] → [CLOUD] Connected to Cloud at ${server}:${serverPort}`);
+    
+    // Send unique ID as the first message to identify this proxy/device
+    cloudSocket.write(`[${uniqueId}]`);
+    debug(`[PROXY] → [CLOUD] Sent unique ID: ${uniqueId}`);
 
     const context = new Context(cloudSocket, master, masterPort, server, serverPort, uniqueId);
     gCloudConnections.push(context);
     log(`[PROXY] → [CLOUD] New free connection #${gCloudConnections.length} to the Cloud at ${server}:${serverPort}`);
   });
 
+  cloudSocket.on('error', (err) => {
+    error(`[PROXY] → [CLOUD] Failed to connect to Cloud: ${err.message}`);
+  });
+
   log(`[PROXY] → [CLOUD] Attempting to start a new free connection for ${config.uniqueId} to the Cloud at ${server}:${serverPort}`);
 }
 
+
 ////////////////
 // Restarting //
 ////////////////
@@ -105,7 +115,7 @@ export function cleanStart(restart: boolean = false) {
         context.deviceSocket.end();
         context.deviceSocket = null;
       }
-      context.cloudSocket.close();
+      context.cloudSocket.end();
       context.cloudSocket = null;
     });
     gCloudConnections.splice(0, gCloudConnections.length); // clear the array
@@ -129,14 +139,14 @@ export class Context {
   master: string;
   masterPort: number;
 
-  cloudSocket: WebSocket;
+  cloudSocket: net.Socket;
   server: string;
   serverPort: number;
 
   // unique identifier for this device-gateway combination
   uniqueId: string; 
 
-  constructor(cloudSocket: WebSocket, master: string, masterPort: number, server: string, serverPort: number, uniqueId: string) {
+  constructor(cloudSocket: net.Socket, master: string, masterPort: number, server: string, serverPort: number, uniqueId: string) {
     this.deviceSocket = null;
     this.master = master;
     this.masterPort = masterPort;
@@ -152,12 +162,12 @@ export class Context {
 
   setupCloudSocket() {
     // set up handlers for the cloud socket
-    this.cloudSocket.on('message', message => {
-      this.handleDataFromCloud(message as Buffer);
+    this.cloudSocket.on('data', data => {
+      this.handleDataFromCloud(data as Buffer);
     });
 
-    this.cloudSocket.on('close', (code, reason) => {
-      warning('[CLOUD] Connection closed: ' + code + ' ' + reason);
+    this.cloudSocket.on('close', () => {
+      warning('[CLOUD] Connection closed');
       if (this.deviceSocket) {
         this.deviceSocket.end();
         this.deviceSocket = null;
@@ -174,28 +184,33 @@ export class Context {
   }
 
   handleDataFromCloud(data: Buffer) {
-    debug(`[CLOUD] → [PROXY]: Data from Cloud: ${data.toString().slice(0, -1)}`);
+    debug(`[CLOUD] → [PROXY]: Data from Cloud: ${data.toString()}`);
 
     if (!this.deviceSocket) {
       // we either have a real client that wants to connect to the device,
       // or we receive a heartbeat from the cloud server
+      // or we receive a connection response [OK], [OK-=2], [ERROR-...]
 
       if (this.isHeartbeatRequest(data)) {
         debug(`[CLOUD] → [PROXY]: Received heartbeat from Cloud, returning response.`);
          // respond to the heartbeat of the cloud server
-        this.cloudSocket.send("[72,3]"); // command([Command.HeartbeatStatus, CommandMethod.Heartbeat.server])
+        this.cloudSocket.write("[72,3]"); // command([Command.HeartbeatStatus, CommandMethod.Heartbeat.server])
 
+      } else if (this.isConnectionResponse(data)) {
+        debug(`[CLOUD] → [PROXY]: Received connection response from Cloud: ${data.toString()}`);
+        // Handle connection response from the cloud server
+        
       } else {
-        // There is incomming data, it's a fresh connection, so: a new client wants to connect to the device
+        // There is real incomming data, it's a fresh connection, so: a new client wants to connect to the device
         // 1) create a new (free) connection to the cloud server for the next client
         // 2) connect to the device and send the initial data
-        log(`[PROXY] → [CLOUD] New client connection, creating new free connection for this proxy/device: ${this.uniqueId}.`);
+        log(`[PROXY] → [CLOUD] New client connection, creating new free connection for this proxy/device: ${config.uniqueId}.`);
         makeNewCloudConnection(this.master, this.masterPort, this.server, this.serverPort, this.uniqueId);
         this.makeDeviceConnection(this.master, this.masterPort, data);
       }
 
     } else if (this.deviceSocket.readyState === 'open') {
-      this.deviceSocket.write(data);
+      this.deviceSocket.write(new Uint8Array(data));
       debug(`[PROXY] → [DEVICE] forwarding data to device: ${data.toString().slice(0, -1)}`);
 
     } else {
@@ -212,17 +227,23 @@ export class Context {
     
       // Connect to local device and send the data that came in from the cloud
       this.deviceSocket.connect(port, address, () => {
+        // Check if socket is still valid (not cleaned up by removeConnection)
+        if (!this.deviceSocket) {
+          warning(`[PROXY] → [DEVICE] Device socket was cleaned up before connection completed`);
+          return;
+        }
+        
         log(`[PROXY] → [DEVICE] Connected to local device at ${address}:${port}`);
 
         this.setUpDeviceSocket();
   
         log(`[PROXY] → [DEVICE] Sending initial message: ${data.toString().slice(0, -1)}`);
-        this.deviceSocket.write(data);
+        this.deviceSocket.write(new Uint8Array(data));
       });
 
     } else if (this.deviceSocket.readyState === 'open') {
         warning(`[PROXY] → [DEVICE] Device socket already open, sending data directly -- STRANGE !!`);
-        this.deviceSocket.write(data);
+        this.deviceSocket.write(new Uint8Array(data));
 
     } else {
       error(`[PROXY] → [DEVICE] Device socket exists, but is not open yet !!`);
@@ -230,10 +251,15 @@ export class Context {
   }
 
   setUpDeviceSocket() {
+    if (!this.deviceSocket) {
+      error(`[PROXY] → [DEVICE] Cannot set up device socket - socket is null`);
+      return;
+    }
+
     this.deviceSocket.on('data', (data: Buffer) => {
       const message = data.toString('utf-8');
       debug(`[DEVICE] → [PROXY] forwarding data to Cloud: ${message.slice(0, -1)}`);
-      this.cloudSocket.send(message);
+      this.cloudSocket.write(message);
     });
 
     this.deviceSocket.on('close', () => {
@@ -248,12 +274,18 @@ export class Context {
   }
 
   removeConnection() {
-    this.deviceSocket = null;
+    // Clean up device socket
+    if (this.deviceSocket) {
+      if (!this.deviceSocket.destroyed) {
+        this.deviceSocket.end();
+      }
+      this.deviceSocket = null;
+    }
 
     // remove this context and close the cloud socket
     const index = gCloudConnections.indexOf(this);
     if (index !== -1) {
-      this.cloudSocket.close();
+      this.cloudSocket.end();
       this.cloudSocket = null;
       gCloudConnections.splice(index, 1);
       log(`[PROXY] → [CLOUD] Closed socket to Cloud and removed context for device ${this.master}`);
@@ -262,7 +294,6 @@ export class Context {
     if (gCloudConnections.length === 0) {
         log(`[PROXY] → [CLOUD] No more cloud connections, restarting proxy.`);
       // just to be sure: restart...
-
       if (config.kind === "pm2") {
         // PM2 should restart us.
         log(`[PROXY] → [CLOUD] PM2 should restart us, exiting now.`);
@@ -297,19 +328,21 @@ export class Context {
 
   // check if it's a heartbeat request from the server
   isHeartbeatRequest(data: Buffer): boolean {
-    // heartbeatKind = (poll = 1, poll_old = 2, serve = 3)
-
-    if (typeof data === 'string') {
-      return data === "[215,3]";
+    // hearbeatKind = (poll = 1, poll_old = 2, serve = 3)
+    return ((data[0] === 91) &&           // [
+            (data[1] === 50) &&           // 2
+            (data[2] === 49) &&           // 1
+            (data[3] === 53) &&           // 5
+            (data[4] === 44) &&           // ,
+            (data[5] === 51) &&           // 3
+            (data[6] === 93));            // ]
+  }
 
-    } else {
-      return ((data[0] === 91) &&           // [
-              (data[1] === 50) &&           // 2
-              (data[2] === 49) &&           // 1
-              (data[3] === 53) &&           // 5
-              (data[4] === 44) &&           // ,
-              (data[5] === 51) &&           // 3
-              (data[6] === 93));            // ]
-    }
+  // check if it's a server response after connecting and sending our uniqueID
+  isConnectionResponse(data: Buffer): boolean {
+    const message = data.toString();
+    
+    // Check for various server response patterns
+    return (message.startsWith('[OK')) || (message.startsWith('[ERROR'));
   }
 }