elero-usb-transmitter-client 1.1.3 → 1.1.4

package/README.md

@@ -84,6 +84,11 @@ await client.close()
 
 ## Changelog
 
+### 1.1.4
+
+- Added `prepublishOnly` script to ensure fresh build before publish
+- Explicitly added `dist` to `files` list in `package.json`
+
 ### 1.1.3
 
 - Moved `commander` and `inquirer` to `dependencies` (fix runtime error)

package/package.json

@@ -1,17 +1,21 @@
 {
   "name": "elero-usb-transmitter-client",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
   "scripts": {
     "test": "jest --config jest.json",
     "build": "tsc",
-    "setup": "npm install"
+    "setup": "npm install",
+    "prepublishOnly": "npm run build"
   },
+  "files": [
+    "dist"
+  ],
   "bin": {
-    "elero-usb-transmitter-client": "./dist/src/cli.js",
-    "elero-cli": "./dist/src/cli.js"
+    "elero-usb-transmitter-client": "dist/src/cli.js",
+    "elero-cli": "dist/src/cli.js"
   },
   "repository": {
     "type": "git",
@@ -47,4 +51,4 @@
     "lodash": "^4.17.15",
     "serialport": "^13.0.0"
   }
-}
+}

package/.eslintrc.json

@@ -1,9 +0,0 @@
-{
-    "extends": ["plugin:prettier/recommended"],
-
-    "plugins": ["prettier"],
-
-    "rules": {
-        "prettier/prettier": "error"
-    }
-}

package/.github/workflows/nodejs.yml

@@ -1,27 +0,0 @@
-name: Node.js CI
-
-on:
-  push:
-    branches: [ main, develop ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [18.x, 20.x, 22.x]
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v3
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: npm ci
-    - run: npm run build
-    - run: npm test

package/.prettierrc

@@ -1,6 +0,0 @@
-{
-  "semi": false,
-  "singleQuote": true,
-  "tabWidth": 2,
-  "useTabs": false
-}

package/.vscode/launch.json

@@ -1,22 +0,0 @@
-{
-  // Use IntelliSense to learn about possible attributes.
-  // Hover to view descriptions of existing attributes.
-  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "type": "node",
-      "name": "vscode-jest-tests",
-      "request": "launch",
-      "args": [
-        "--runInBand",
-        "--config=jest.json"
-      ],
-      "cwd": "${workspaceFolder}",
-      "console": "integratedTerminal",
-      "internalConsoleOptions": "neverOpen",
-      "disableOptimisticBPs": true,
-      "program": "${workspaceFolder}/node_modules/jest/bin/jest"
-    }
-  ]
-}

package/jest.json

@@ -1,18 +0,0 @@
-{
-    "transform": {
-        "^.+\\.(t|j)sx?$": "ts-jest"
-    },
-    "testRegex": "(/test/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$",
-    "testPathIgnorePatterns": [
-        "/node_modules/",
-        "/dist/"
-    ],
-    "moduleFileExtensions": [
-        "ts",
-        "tsx",
-        "js",
-        "jsx",
-        "json",
-        "node"
-    ]
-}

package/src/UsbTransmitterClient.ts

@@ -1,214 +0,0 @@
-import { SerialPort } from 'serialport'
-import * as _ from 'lodash'
-import {
-  BYTE_HEADER,
-  BYTE_LENGTH_2,
-  RESPONSE_LENGTH_CHECK,
-  RESPONSE_LENGTH_SEND,
-  BYTE_LENGTH_5,
-  RESPONSE_LENGTH_INFO,
-  BYTE_LENGTH_4,
-} from './domain/constants'
-import { Response } from './model/Response'
-import { ControlCommand, EasyCommand, InfoData } from './domain/enums'
-import { Mutex } from 'async-mutex'
-
-const DEFAULT_BAUDRATE = 38400
-const DEFAULT_BYTESIZE = 8
-const DEFAULT_PARITY = 'none'
-const DEFAULT_STOPBITS = 1
-
-const mutex = new Mutex()
-
-export class UsbTransmitterClient {
-  serialPort: SerialPort<any>
-
-  constructor(devPath: string) {
-    this.serialPort = new SerialPort({
-      path: devPath,
-      baudRate: DEFAULT_BAUDRATE,
-      dataBits: DEFAULT_BYTESIZE,
-      parity: DEFAULT_PARITY,
-      stopBits: DEFAULT_STOPBITS,
-      autoOpen: false,
-    })
-  }
-
-  public open(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      if (!this.serialPort.isOpen) {
-        this.serialPort.open((error) => {
-          if (error) reject(error)
-          this.serialPort.flush((error) => {
-            if (error) reject(error)
-            resolve()
-          })
-        })
-      }
-    })
-  }
-
-  public close(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      this.serialPort.close((error) => {
-        if (error) reject(error)
-        resolve()
-      })
-    })
-  }
-
-  public async checkChannels(): Promise<number[]> {
-    const data = [BYTE_HEADER, BYTE_LENGTH_2, EasyCommand.EASY_CHECK]
-    const release = await mutex.acquire()
-    try {
-      await this.sendCommand(data)
-      const responseBytes = await this.waitForResponse(RESPONSE_LENGTH_CHECK)
-      const response = this.parseResponse(responseBytes)
-      return response.activeChannels
-    } finally {
-      release()
-    }
-  }
-
-  public async getInfo(channel: number): Promise<Response> {
-    let lowChannels = (1 << (channel - 1)) & 0xff
-    let highChannels = (1 << (channel - 1)) >> 8
-
-    const data = [
-      BYTE_HEADER,
-      BYTE_LENGTH_4,
-      EasyCommand.EASY_INFO,
-      highChannels,
-      lowChannels,
-    ]
-    const release = await mutex.acquire()
-    try {
-      await this.sendCommand(data)
-      const responseBytes = await this.waitForResponse(RESPONSE_LENGTH_INFO)
-      const response = this.parseResponse(responseBytes)
-      return response
-    } finally {
-      release()
-    }
-  }
-
-  public async sendControlCommand(
-    channel: number,
-    controlCommand: ControlCommand
-  ): Promise<Response> {
-    let lowChannels = (1 << (channel - 1)) & 0xff
-    let highChannels = (1 << (channel - 1)) >> 8
-
-    const data = [
-      BYTE_HEADER,
-      BYTE_LENGTH_5,
-      EasyCommand.EASY_SEND,
-      highChannels,
-      lowChannels,
-      controlCommand,
-    ]
-    const release = await mutex.acquire()
-    try {
-      await this.sendCommand(data)
-      const responseBytes = await this.waitForResponse(RESPONSE_LENGTH_INFO)
-      const response = this.parseResponse(responseBytes)
-      return response
-    } finally {
-      release()
-    }
-  }
-
-  private waitForResponse(length: number): Promise<Buffer> {
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        cleanup()
-        reject(new Error('Timeout waiting for response'))
-      }, 2000)
-
-      const tryRead = () => {
-        const buffer = this.serialPort.read(length)
-        if (buffer) {
-          cleanup()
-          resolve(buffer)
-        }
-      }
-
-      const cleanup = () => {
-        clearTimeout(timeout)
-        this.serialPort.removeListener('readable', tryRead)
-      }
-
-      this.serialPort.on('readable', tryRead)
-      tryRead()
-    })
-  }
-
-  private sendCommand(data: number[]): Promise<number> {
-    const checksum = this.calculateChecksum(data)
-    data.push(checksum)
-
-    return new Promise((resolve, reject) => {
-      this.serialPort.flush((error) => {
-        if (error) reject(error)
-        this.serialPort.write(data, (error: Error | null | undefined) => {
-          if (error) reject(error)
-          resolve(data.length)
-        })
-      })
-    })
-  }
-
-  private readResponseBytes(length: number): string | Buffer | null {
-    //Get the serial data from the serial port.
-    var response = this.serialPort.read(length)
-    return response
-  }
-
-  private calculateChecksum(data: number[]): number {
-    //Calculate checksum.
-    //All the sum of all bytes (Header to CS) must be 0x00.
-    const sum = _.sum(data)
-    const result = (256 - sum) % 256
-    return result
-  }
-
-  private getActiveChannels(byte: number, start: number): number[] {
-    var channels: number[] = new Array()
-    for (let i = 0; i < 9; i++) {
-      if (((byte >> i) & 1) == 1) {
-        const channel = i + start
-        channels.push(channel)
-      }
-    }
-    return channels
-  }
-
-  private parseResponse(bytes: Buffer): Response {
-    const activeHighChannels = this.getActiveChannels(bytes[3], 9)
-    const activeLowChannels = this.getActiveChannels(bytes[4], 1)
-    const activeChannels = _.concat(activeLowChannels, activeHighChannels)
-    const response: Response = {
-      header: bytes[0],
-      length: bytes[1],
-      command: bytes[2],
-      activeChannels: activeChannels,
-      checksum: -1,
-      status: null,
-      statusCode: -1,
-    }
-    if (bytes.length == RESPONSE_LENGTH_CHECK) {
-      response.checksum = bytes[5]
-      //Easy Ack (the answer on Easy Info)
-    } else if (bytes.length == RESPONSE_LENGTH_SEND) {
-      if (bytes[5] in InfoData) {
-        response.status = bytes[5] as InfoData
-      } else {
-        response.status = InfoData.INFO_UNKNOWN
-      }
-      response.checksum = bytes[6]
-    } else {
-      response.status = InfoData.INFO_UNKNOWN
-    }
-    return response
-  }
-}

package/src/cli.ts

@@ -1,167 +0,0 @@
-#!/usr/bin/env node
-import { Command } from 'commander'
-import * as inquirer from 'inquirer'
-import { UsbTransmitterClient } from './UsbTransmitterClient'
-import { ControlCommand } from './domain/enums'
-import { SerialPort } from 'serialport'
-
-const program = new Command()
-let client: UsbTransmitterClient | null = null
-
-program
-    .version('1.0.0')
-    .option('-p, --port <path>', 'Path to serial port')
-    .parse(process.argv)
-
-const options = program.opts()
-
-async function main() {
-    let portPath = options.port
-
-    if (!portPath) {
-        const ports = await SerialPort.list()
-        const portChoices = ports.map((p) => ({ name: `${p.path} ${p.manufacturer || ''}`, value: p.path }))
-        
-        if (portChoices.length === 0) {
-            console.error('No serial ports found. Please specify one with --port.')
-            process.exit(1)
-        }
-
-        const answer = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'port',
-                message: 'Select Serial Port',
-                choices: portChoices,
-            },
-        ])
-        portPath = answer.port
-    }
-
-    client = new UsbTransmitterClient(portPath)
-
-    try {
-        await client.open()
-        console.log(`Connected to ${portPath}`)
-        await mainMenu()
-    } catch (error) {
-        console.error('Error connecting to device:', error)
-        process.exit(1)
-    }
-}
-
-async function mainMenu() {
-    const answer = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'action',
-            message: 'Main Menu',
-            choices: [
-                { name: 'Check Channels', value: 'check' },
-                { name: 'Select Channel', value: 'select' },
-                new inquirer.Separator(),
-                { name: 'Exit', value: 'exit' },
-            ],
-        },
-    ])
-
-    switch (answer.action) {
-        case 'check':
-            await checkChannels()
-            break
-        case 'select':
-            await selectChannel()
-            break
-        case 'exit':
-            await client!.close()
-            process.exit(0)
-    }
-}
-
-async function checkChannels() {
-    console.log('Checking channels...')
-    try {
-        const channels = await client!.checkChannels()
-        console.log('Active Channels:', channels.join(', '))
-    } catch (error) {
-        console.error('Error checking channels:', error)
-    }
-    await mainMenu()
-}
-
-async function selectChannel() {
-    const answer = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'channel',
-            message: 'Enter Channel Number (1-9):',
-            validate: (input) => {
-                const num = parseInt(input, 10)
-                if (isNaN(num) || num < 1 || num > 9) {
-                    return 'Please enter a number between 1 and 9'
-                }
-                return true
-            },
-        },
-    ])
-
-    const channel = parseInt(answer.channel, 10)
-    await channelMenu(channel)
-}
-
-async function channelMenu(channel: number) {
-    const answer = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'action',
-            message: `Channel ${channel} Actions`,
-            choices: [
-                { name: 'Get Info', value: 'info' },
-                { name: 'Move Up', value: 'up' },
-                { name: 'Move Down', value: 'down' },
-                { name: 'Stop', value: 'stop' },
-                new inquirer.Separator(),
-                { name: 'Back to Main Menu', value: 'back' },
-            ],
-        },
-    ])
-
-    if (answer.action === 'back') {
-        await mainMenu()
-        return
-    }
-
-    try {
-        if (answer.action === 'info') {
-            const info = await client!.getInfo(channel)
-            console.log('Channel Info:', info)
-        } else {
-            let cmd: ControlCommand
-            switch (answer.action) {
-                case 'up':
-                    cmd = ControlCommand.up
-                    break
-                case 'down':
-                    cmd = ControlCommand.down
-                    break
-                case 'stop':
-                    cmd = ControlCommand.stop
-                    break
-                default:
-                    throw new Error('Unknown command')
-            }
-            console.log(`Sending ${answer.action} command to channel ${channel}...`)
-            const response = await client!.sendControlCommand(channel, cmd)
-            console.log('Response:', response)
-        }
-    } catch (error) {
-        console.error('Error executing command:', error)
-    }
-
-    await channelMenu(channel)
-}
-
-main().catch((err) => {
-    console.error('Unexpected error:', err)
-    process.exit(1)
-})

package/src/domain/constants.ts

@@ -1,52 +0,0 @@
-import { Dictionary } from './types'
-
-// Default serial connection details.
-export const DEFAULT_BAUDRATE = 38400
-export const DEFAULT_BYTESIZE = 8
-export const DEFAULT_PARITY = 'none'
-export const DEFAULT_STOPBITS = 1
-
-// values to bit shift.
-export const HEX_255: number = 0xff
-export const BIT_8: number = 8
-
-// Header for all command.
-export const BYTE_HEADER: number = 0xaa
-// command lengths
-export const BYTE_LENGTH_2: number = 0x02
-export const BYTE_LENGTH_4: number = 0x04
-export const BYTE_LENGTH_5: number = 0x05
-
-// required response lenth.
-export const RESPONSE_LENGTH_CHECK: number = 6
-// required response lenth.
-export const RESPONSE_LENGTH_SEND: number = 7
-// Required response lenth.
-export const RESPONSE_LENGTH_INFO: number = 7
-// for Serial error handling
-export const NO_SERIAL_RESPONSE: string = ''
-
-// Info to receive response.
-export const INFO_UNKNOWN = 'unknown response'
-export const INFO_NO_INFORMATION = 'no information'
-export const INFO_TOP_POSITION_STOP = 'top position stop'
-export const INFO_BOTTOM_POSITION_STOP = 'bottom position stop'
-export const INFO_INTERMEDIATE_POSITION_STOP = 'intermediate position stop'
-export const INFO_TILT_VENTILATION_POS_STOP = 'tilt ventilation position stop'
-export const INFO_BLOCKING = 'blocking'
-export const INFO_OVERHEATED = 'overheated'
-export const INFO_TIMEOUT = 'timeout'
-export const INFO_START_TO_MOVE_UP = 'start to move up'
-export const INFO_START_TO_MOVE_DOWN = 'start to move down'
-export const INFO_MOVING_UP = 'moving up'
-export const INFO_MOVING_DOWN = 'moving down'
-export const INFO_STOPPED_IN_UNDEFINED_POSITION =
-  'stopped in undefined position'
-export const INFO_TOP_POS_STOP_WICH_TILT_POS =
-  'top position stop wich is tilt position'
-export const INFO_BOTTOM_POS_STOP_WICH_INT_POS =
-  'bottom position stop wich is intermediate position'
-export const INFO_SWITCHING_DEVICE_SWITCHED_OFF =
-  'switching device switched off'
-export const INFO_SWITCHING_DEVICE_SWITCHED_ON = 'switching device switched on'
-

package/src/domain/enums.ts

@@ -1,36 +0,0 @@
-export enum ControlCommand {
-  stop = 0x10,
-  up = 0x20,
-  ventilationPosTilting = 0x24,
-  down = 0x40,
-  intermediatePos = 0x44,
-}
-
-export enum EasyCommand {
-  EASY_CHECK = 0x4a,
-  EASY_CONFIRM = 0x4b,
-  EASY_SEND = 0x4c,
-  EASY_ACK = 0x4d,
-  EASY_INFO = 0x4e,
-}
-
-export enum InfoData {
-  INFO_UNKNOWN = -1,
-  INFO_NO_INFORMATION = 0x00,
-  INFO_TOP_POSITION_STOP = 0x01,
-  INFO_BOTTOM_POSITION_STOP = 0x02,
-  INFO_INTERMEDIATE_POSITION_STOP = 0x03,
-  INFO_TILT_VENTILATION_POS_STOP = 0x04,
-  INFO_BLOCKING = 0x05,
-  INFO_OVERHEATED = 0x06,
-  INFO_TIMEOUT = 0x07,
-  INFO_START_TO_MOVE_UP = 0x08,
-  INFO_START_TO_MOVE_DOWN = 0x09,
-  INFO_MOVING_UP = 0x0a,
-  INFO_MOVING_DOWN = 0x0b,
-  INFO_STOPPED_IN_UNDEFINED_POSITION = 0x0d,
-  INFO_TOP_POS_STOP_WICH_TILT_POS = 0x0e,
-  INFO_BOTTOM_POS_STOP_WICH_INT_POS = 0x0f,
-  INFO_SWITCHING_DEVICE_SWITCHED_OFF = 0x10,
-  INFO_SWITCHING_DEVICE_SWITCHED_ON = 0x11,
-}

package/src/domain/types.ts

@@ -1 +0,0 @@
-export type Dictionary<T> = { [key: number]: T }

package/src/index.ts

@@ -1,6 +0,0 @@
-export { UsbTransmitterClient } from './UsbTransmitterClient'
-export { Response } from './model/Response'
-export * from './model/Response'
-export * from './domain/constants'
-export * from './domain/enums'
-export * from './domain/types'

package/src/model/Response.ts

@@ -1,17 +0,0 @@
-import { EasyCommand, InfoData } from "../domain/enums";
-
-export interface Response {
-  header: number
-
-  length: number
-
-  command: EasyCommand
-
-  activeChannels: number[]
-
-  checksum: number
-
-  status: InfoData | null
-
-  statusCode: number
-}

package/test/UsbTransmitterClient.test.ts

@@ -1,39 +0,0 @@
-import { UsbTransmitterClient } from "../src/UsbTransmitterClient"
-import { ControlCommand, EasyCommand, InfoData } from "../src/domain/enums"
-import * as fs from 'fs'
-
-jest.setTimeout(200000)
-
-const devPath = '/dev/ttyUSB0'
-const client = new UsbTransmitterClient(devPath)
-
-const aktiveChannelsForTest = [1, 2]
-
-// Skip tests if hardware not present
-const describeHardware = fs.existsSync(devPath) ? describe : describe.skip
-
-describeHardware('Integration Tests (Hardware)', () => {
-
-  test('checkChannels', async () => {
-    await client.open()
-    const channels = await client.checkChannels()
-    expect(channels).toEqual(aktiveChannelsForTest)
-    await client.close()
-  })
-
-  test('getInfo', async () => {
-    await client.open()
-    const response = await client.getInfo(1)
-    console.log(response)
-    expect(response.command).toEqual(EasyCommand.EASY_ACK)
-    await client.close()
-  })
-
-  test('sendControlCommand', async () => {
-    await client.open()
-    const response = await client.sendControlCommand(1, ControlCommand.down)
-    console.log(response)
-    expect(response.status).toEqual(InfoData.INFO_MOVING_DOWN)
-    await client.close()
-  })
-})

package/test/UsbTransmitterClientMock.test.ts

@@ -1,182 +0,0 @@
-
-import { UsbTransmitterClient } from '../src/UsbTransmitterClient'
-import { ControlCommand, EasyCommand, InfoData } from '../src/domain/enums'
-import { SerialPort } from 'serialport'
-import { BYTE_HEADER } from '../src/domain/constants'
-
-// Mock entire serialport module
-jest.mock('serialport')
-
-describe('UsbTransmitterClient (Mocked)', () => {
-    let client: UsbTransmitterClient
-    let mockSerialPortInstance: any
-
-    beforeEach(() => {
-        // Reset mocks
-        jest.clearAllMocks()
-
-        // Setup mock instance
-        mockSerialPortInstance = {
-            isOpen: false,
-            open: jest.fn((cb) => {
-                mockSerialPortInstance.isOpen = true
-                if (cb) cb(null)
-            }),
-            close: jest.fn((cb) => {
-                mockSerialPortInstance.isOpen = false
-                if (cb) cb(null)
-            }),
-            write: jest.fn((data, cb) => {
-                if (cb) cb(null)
-            }),
-            flush: jest.fn((cb) => {
-                if (cb) cb(null)
-            }),
-            once: jest.fn(),
-            read: jest.fn(),
-            pipe: jest.fn(),
-            on: jest.fn(),
-            removeListener: jest.fn()
-        }
-
-            // When new SerialPort() is called, return our mock instance
-            ; (SerialPort as unknown as jest.Mock).mockImplementation(() => mockSerialPortInstance)
-
-        client = new UsbTransmitterClient('/dev/ttyMOCKED')
-    })
-
-    test('open() should open the serial port', async () => {
-        await client.open()
-        expect(mockSerialPortInstance.open).toHaveBeenCalled()
-        expect(mockSerialPortInstance.flush).toHaveBeenCalled()
-    })
-
-    test('close() should close the serial port', async () => {
-        await client.close()
-        expect(mockSerialPortInstance.close).toHaveBeenCalled()
-    })
-
-    test('checkChannels() calls correct command and parses response', async () => {
-        await client.open()
-
-        // Simulate "readable" event and data read
-        mockSerialPortInstance.once.mockImplementation((event: string, cb: Function) => {
-            if (event === 'readable') {
-                // Trigger the callback immediately to simulate data ready
-                cb()
-            }
-        })
-
-        // Mock response for check channels (Head, Len, Cmd, Byte3...CS)
-        // Response length check is 6 bytes.
-        // Byte 3 is bitmap of active channels (1-8). let's say ch 1 and 2 are active (binary 00000011 = 3)
-        const responseBuffer = Buffer.from([
-            BYTE_HEADER, // 0xAA
-            0x04, // Length
-            EasyCommand.EASY_CHECK,
-            0x00, // High channels (starts at 9)
-            0x03, // Low channels (starts at 1, so 1 & 2)
-            0x00 // Checksum (ignored for now in mock, or we calculate it if logic is strict)
-        ])
-        // Fix checksum if logic requires it: 256 - sum
-        const sum = responseBuffer[0] + responseBuffer[1] + responseBuffer[2] + responseBuffer[3] + responseBuffer[4]
-        responseBuffer[5] = (256 - (sum % 256)) % 256
-
-        mockSerialPortInstance.read.mockReturnValue(responseBuffer)
-
-        const channels = await client.checkChannels()
-        expect(channels).toEqual(expect.arrayContaining([1, 2]))
-        expect(mockSerialPortInstance.write).toHaveBeenCalledWith(
-            expect.arrayContaining([BYTE_HEADER, 0x02, EasyCommand.EASY_CHECK]),
-            expect.any(Function)
-        )
-    })
-
-    test('sendControlCommand() sends correct bytes', async () => {
-        await client.open()
-
-        mockSerialPortInstance.once.mockImplementation((event: string, cb: Function) => {
-            if (event === 'readable') cb()
-        })
-
-        // Response for Info (length 7)
-        // 0: AA, 1: 05, 2: EASY_SEND, 3: high, 4: low, 5: status, 6: CS
-        const responseBuffer = Buffer.from([
-            BYTE_HEADER,
-            0x05,
-            EasyCommand.EASY_SEND,
-            0x00,
-            0x01, // Channel 1 bit mask
-            InfoData.INFO_MOVING_DOWN,
-            0x00
-        ])
-        const sum = responseBuffer.slice(0, 6).reduce((a, b) => a + b, 0)
-        responseBuffer[6] = (256 - (sum % 256)) % 256
-
-        mockSerialPortInstance.read.mockReturnValue(responseBuffer)
-
-        const response = await client.sendControlCommand(1, ControlCommand.down)
-
-        expect(response.status).toBe(InfoData.INFO_MOVING_DOWN)
-
-        // Verify write arguments
-        // Data: [AA, 05, EASY_SEND, high, low, cmd, CS]
-        // Channel 1 -> low=1, high=0
-        expect(mockSerialPortInstance.write).toHaveBeenCalledWith(
-            expect.arrayContaining([
-                BYTE_HEADER,
-                0x05,
-                EasyCommand.EASY_SEND,
-                0,
-                1,
-                ControlCommand.down
-            ]),
-            expect.any(Function)
-        )
-    })
-    test('getInfo() should handle fragmented packets (reproduction fix)', async () => {
-        await client.open()
-
-        let readableCallback: Function | null = null;
-        mockSerialPortInstance.on.mockImplementation((event: string, cb: Function) => {
-            if (event === 'readable') {
-                readableCallback = cb
-            }
-        })
-
-        let readCallCount = 0
-        mockSerialPortInstance.read.mockImplementation((len: number) => {
-            readCallCount++
-            if (readCallCount === 1) {
-                return null // Not enough data yet
-            }
-            // Return dummy response buffer for getInfo call
-            const responseBuffer = Buffer.from([
-                BYTE_HEADER,
-                0x05,
-                EasyCommand.EASY_SEND,
-                0x00,
-                0x01,
-                InfoData.INFO_MOVING_DOWN,
-                0x00
-            ])
-            const sum = responseBuffer.slice(0, 6).reduce((a, b) => a + b, 0)
-            responseBuffer[6] = (256 - (sum % 256)) % 256
-            return responseBuffer
-        })
-
-        const infoPromise = client.getInfo(1)
-
-        // Wait a tick to ensure tryRead() ran once and failed
-        await new Promise(r => process.nextTick(r))
-
-        // Now trigger readable event again (simulation of second packet arriving)
-        if (readableCallback) {
-            (readableCallback as Function)()
-        }
-
-        const response = await infoPromise
-        expect(response.status).toBe(InfoData.INFO_MOVING_DOWN)
-        expect(readCallCount).toBeGreaterThanOrEqual(2)
-    })
-})