dsc-itv2-client 1.0.21 → 1.0.23

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsc-itv2-client",
   "author": "fajitacat",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "description": "Reverse engineered DSC ITV2 Protocol Client Library for TL280R Communicator - Monitor and control DSC alarm panels",
   "main": "src/index.js",
   "type": "module",

package/src/ITV2Client.js

@@ -379,9 +379,23 @@ export class ITV2Client extends EventEmitter {
             case CMD.TIME_DATE_BROADCAST:
                 this._handleTimeDateBroadcast(parsed);
                 break;
+            case CMD.ZONE_STATUS:
+                this._handleZoneStatusResponse(parsed);
+                break;
+            case CMD.PARTITION_STATUS:
+                this._handlePartitionStatusResponse(parsed);
+                break;
+            case CMD.GLOBAL_STATUS:
+                this._handleGlobalStatusResponse(parsed);
+                break;
             default:
                 if (this.handshakeState === 'ESTABLISHED') {
-                    this._log(`[Session] Unhandled command ${CMD_NAMES[cmd] || '0x' + cmd?.toString(16)}`);
+                    const cmdHex = cmd ? '0x' + cmd.toString(16).padStart(4, '0') : 'null';
+                    const cmdName = CMD_NAMES[cmd] || 'UNKNOWN';
+                    this._logMinimal(`[Session] Received command ${cmdName} (${cmdHex})`);
+                    if (parsed.commandData && parsed.commandData.length > 0) {
+                        this._logMinimal(`[Session] Data (${parsed.commandData.length} bytes): ${parsed.commandData.toString('hex')}`);
+                    }
                     this._sendPacket(this.session.buildSimpleAck());
                 }
                 break;
@@ -569,10 +583,17 @@ export class ITV2Client extends EventEmitter {
     }
 
     _handleCommandResponse(parsed) {
-        const responseCode = parsed.commandData?.[0] || 0;
+        const data = parsed.commandData;
+        const responseCode = data?.[0] || 0;
         const appSeqAsEcho = parsed.appSequence;
 
-        this._log(`[Handshake] Got COMMAND_RESPONSE (echoed app_seq: ${appSeqAsEcho}, response_code: ${responseCode}), sending ACK`);
+        this._log(`[Session] Got COMMAND_RESPONSE (app_seq: ${appSeqAsEcho}, response_code: ${responseCode})`);
+
+        // Log full data in established state for debugging query responses
+        if (this.handshakeState === 'ESTABLISHED' && data && data.length > 1) {
+            this._logMinimal(`[Command Response] Response code: ${responseCode}, data (${data.length} bytes): ${data.toString('hex')}`);
+            this.emit('command:response', { responseCode, appSequence: appSeqAsEcho, data });
+        }
 
         const ack = this.session.buildSimpleAck();
         this._sendPacket(ack);
@@ -655,6 +676,75 @@ export class ITV2Client extends EventEmitter {
         this._sendPacket(this.session.buildSimpleAck());
     }
 
+    // ==================== Status Query Response Handlers ====================
+
+    _handleZoneStatusResponse(parsed) {
+        const data = parsed.commandData;
+        this._logMinimal(`[Zone Status] Received zone status response`);
+        this._log(`[Zone Status] Raw data (${data?.length || 0} bytes): ${data?.toString('hex') || 'none'}`);
+
+        if (data && data.length >= 3) {
+            // Response format: [ZoneNumber 2B BE][StatusByte 1B][...more zones...]
+            const zoneNum = data.readUInt16BE(0);
+            const statusByte = data[2];
+
+            // Update internal state
+            const fullStatus = this.eventHandler.handleZoneStatus(zoneNum, statusByte);
+
+            this._logMinimal(`[Zone Status] Zone ${zoneNum}: ${fullStatus.open ? 'OPEN' : 'CLOSED'} (0x${statusByte.toString(16)})`);
+
+            // Emit event with full status
+            this.emit('zone:statusResponse', zoneNum, fullStatus);
+            this.emit('zone:status', zoneNum, fullStatus);
+        } else {
+            this._log(`[Zone Status] Empty or invalid response`);
+        }
+
+        this._sendPacket(this.session.buildSimpleAck());
+    }
+
+    _handlePartitionStatusResponse(parsed) {
+        const data = parsed.commandData;
+        this._logMinimal(`[Partition Status] Received partition status response`);
+        this._log(`[Partition Status] Raw data (${data?.length || 0} bytes): ${data?.toString('hex') || 'none'}`);
+
+        if (data && data.length >= 3) {
+            // Response format: [PartitionNumber 2B BE][StatusBytes...]
+            const partitionNum = data.readUInt16BE(0);
+            const statusBytes = data.slice(2);
+
+            this._logMinimal(`[Partition Status] Partition ${partitionNum}: status bytes ${statusBytes.toString('hex')}`);
+
+            // Emit raw event - let consumers parse the detailed status
+            this.emit('partition:statusResponse', partitionNum, statusBytes);
+        } else {
+            this._log(`[Partition Status] Empty or invalid response`);
+        }
+
+        this._sendPacket(this.session.buildSimpleAck());
+    }
+
+    _handleGlobalStatusResponse(parsed) {
+        const data = parsed.commandData;
+        this._logMinimal(`[Global Status] Received global status response`);
+        this._log(`[Global Status] Raw data (${data?.length || 0} bytes): ${data?.toString('hex') || 'none'}`);
+
+        if (data && data.length > 0) {
+            // Emit raw event with full data
+            this.emit('global:statusResponse', data);
+
+            // Log byte breakdown for debugging
+            this._log(`[Global Status] Byte breakdown:`);
+            for (let i = 0; i < data.length && i < 32; i++) {
+                this._log(`  Byte ${i}: 0x${data[i].toString(16).padStart(2, '0')} (${data[i]})`);
+            }
+        } else {
+            this._log(`[Global Status] Empty response`);
+        }
+
+        this._sendPacket(this.session.buildSimpleAck());
+    }
+
     // ==================== Utility Methods ====================
 
     _handleError(error) {

package/src/itv2-session.js

@@ -756,67 +756,121 @@ export class ITv2Session {
     return this.buildCommand(CMD.REQUEST_ACCESS, payload);
   }
 
+  // ==================== VarBytes Encoding ====================
+
   /**
-   * Build status request command
-   * @param {number} statusType - Type of status to request:
-   *   0x10 = Global Status (0x0810)
-   *   0x11 = Zone Status (0x0811)
-   *   0x12 = Partition Status (0x0812)
-   *   0x13 = Zone Bypass Status (0x0813)
-   *   0x14 = System Trouble Status (0x0814)
-   *   0x15 = Alarm Memory Info (0x0815)
-   *   0x16 = Bus Status (0x0816)
-   *   0x17 = Trouble Detail (0x0817)
-   *   0x19 = Door Chime Status (0x0819)
-   * @param {number} partitionOrZone - Partition or zone number (0 = all)
+   * Encode a value as VarBytes (DSC protocol variable-length integer)
+   * Format: [length byte][value bytes in little-endian]
+   * @param {number} value - Value to encode
+   * @returns {Buffer} - VarBytes encoded buffer
    */
-  buildStatusRequest(statusType, partitionOrZone = 0) {
-    // Payload: [status type byte][partition/zone number]
-    const payload = Buffer.from([statusType, partitionOrZone]);
+  encodeVarBytes(value) {
+    if (value < 0x100) {
+      // 1 byte value
+      return Buffer.from([0x01, value & 0xFF]);
+    } else if (value < 0x10000) {
+      // 2 byte value (little-endian)
+      return Buffer.from([0x02, value & 0xFF, (value >> 8) & 0xFF]);
+    } else if (value < 0x1000000) {
+      // 3 byte value (little-endian)
+      return Buffer.from([0x03, value & 0xFF, (value >> 8) & 0xFF, (value >> 16) & 0xFF]);
+    } else {
+      // 4 byte value (little-endian)
+      return Buffer.from([0x04, value & 0xFF, (value >> 8) & 0xFF, (value >> 16) & 0xFF, (value >> 24) & 0xFF]);
+    }
+  }
+
+  // ==================== 0x0800 Command Request Wrapper ====================
+
+  /**
+   * Build a 0x0800 Command Request wrapper
+   * This wraps inner commands for status queries - required by the DSC protocol
+   * Format: [AppSeqNum 1B][CommandToRequest 2B LE][InnerPayload...]
+   * @param {number} innerCommand - The command code to request (e.g., 0x0811)
+   * @param {Buffer} innerPayload - The payload for the inner command
+   * @returns {Buffer} - Complete packet ready to send
+   */
+  buildCommandRequest(innerCommand, innerPayload = Buffer.alloc(0)) {
+    // Get next application sequence number
+    const appSeq = this.appSequence;
+    this.appSequence = (this.appSequence + 1) & 0xFF;
+
+    // Build 0x0800 payload: [AppSeqNum][CommandToRequest LE][InnerPayload]
+    const payload = Buffer.alloc(3 + innerPayload.length);
+    payload[0] = appSeq;
+    payload.writeUInt16LE(innerCommand, 1);  // Command in little-endian
+    innerPayload.copy(payload, 3);
+
+    this.log(`[Session] Building 0x0800 Command Request: innerCmd=0x${innerCommand.toString(16)}, appSeq=${appSeq}`);
+    this.log(`[Session] Inner payload: ${innerPayload.toString('hex')}`);
+
     return this.buildCommand(CMD.STATUS_REQUEST, payload);
   }
 
+  // ==================== Status Query Methods (0x0800 Wrapped) ====================
+
   /**
-   * Build global status request
+   * Build global status request (0x0810 wrapped in 0x0800)
    */
   buildGlobalStatusRequest() {
-    // Send GLOBAL_STATUS (0x0810) command directly, not wrapped in STATUS_REQUEST
-    return this.buildCommand(CMD.GLOBAL_STATUS);
+    // 0x0810 has no payload
+    return this.buildCommandRequest(CMD.GLOBAL_STATUS, Buffer.alloc(0));
   }
 
   /**
-   * Build zone status request
-   * @param {number} zone - Zone number (0 = all zones)
+   * Build zone status request (0x0811 wrapped in 0x0800)
+   * @param {number} startZone - Starting zone number (0 = first zone)
+   * @param {number} numZones - Number of zones to query (default 128)
    */
-  buildZoneStatusRequest(zone = 0) {
-    // Send ZONE_STATUS (0x0811) command directly with zone number
-    const payload = zone > 0 ? Buffer.from([zone]) : Buffer.alloc(0);
-    return this.buildCommand(CMD.ZONE_STATUS, payload);
+  buildZoneStatusRequest(startZone = 0, numZones = 128) {
+    // 0x0811 payload: [ZoneNumber VarBytes][NumberOfZones VarBytes]
+    const zoneBytes = this.encodeVarBytes(startZone);
+    const countBytes = this.encodeVarBytes(numZones);
+    const payload = Buffer.concat([zoneBytes, countBytes]);
+    return this.buildCommandRequest(CMD.ZONE_STATUS, payload);
   }
 
   /**
-   * Build partition status request
+   * Build partition status request (0x0812 wrapped in 0x0800)
    * @param {number} partition - Partition number (0 = all partitions)
+   * @param {number} numPartitions - Number of partitions to query (default 8)
    */
-  buildPartitionStatusRequest(partition = 0) {
-    // Send PARTITION_STATUS (0x0812) command directly with partition number
-    const payload = partition > 0 ? Buffer.from([partition]) : Buffer.alloc(0);
-    return this.buildCommand(CMD.PARTITION_STATUS, payload);
+  buildPartitionStatusRequest(partition = 0, numPartitions = 8) {
+    // 0x0812 payload: [Partition VarBytes][NumberOfPartitions VarBytes]
+    const partBytes = this.encodeVarBytes(partition);
+    const countBytes = this.encodeVarBytes(numPartitions);
+    const payload = Buffer.concat([partBytes, countBytes]);
+    return this.buildCommandRequest(CMD.PARTITION_STATUS, payload);
   }
 
   /**
-   * Build zone bypass status request
+   * Build zone bypass status request (0x0813 wrapped in 0x0800)
    * @param {number} zone - Zone number (0 = all zones)
+   * @param {number} numZones - Number of zones (default 128)
    */
-  buildZoneBypassStatusRequest(zone = 0) {
-    return this.buildStatusRequest(0x13, zone);
+  buildZoneBypassStatusRequest(zone = 0, numZones = 128) {
+    const zoneBytes = this.encodeVarBytes(zone);
+    const countBytes = this.encodeVarBytes(numZones);
+    const payload = Buffer.concat([zoneBytes, countBytes]);
+    return this.buildCommandRequest(CMD.ZONE_BYPASS_STATUS, payload);
   }
 
   /**
-   * Build system trouble status request
+   * Build system trouble status request (0x0814 wrapped in 0x0800)
    */
   buildTroubleStatusRequest() {
-    return this.buildStatusRequest(0x14, 0);
+    // 0x0814 typically has no payload or minimal payload
+    return this.buildCommandRequest(CMD.SYSTEM_TROUBLE_STATUS, Buffer.alloc(0));
+  }
+
+  /**
+   * Build status request command (legacy - simple format)
+   * @deprecated Use buildCommandRequest() with specific inner commands instead
+   */
+  buildStatusRequest(statusType, partitionOrZone = 0) {
+    // Legacy format - kept for backwards compatibility
+    const payload = Buffer.from([statusType, partitionOrZone]);
+    return this.buildCommand(CMD.STATUS_REQUEST, payload);
   }
 
   /**