@blueid/access-cli 0.21.0 → 0.22.0

package/lib/createProvisioningData/action.js

@@ -9,7 +9,7 @@ import { BlueSystemProvisioning } from '../proto/BlueSystem_pb.js'
 
 export default async (
     provisioningFile,
-    { vendorIdentity, hardwareType, hardwareSerialNumber, hardwareVersion, hardwareName, meta, format }
+    { vendorIdentity, hardwareType, hardwareSerialNumber, hardwareVersion, hardwareName, meta, format },
 ) => {
     const { deviceId, terminalPrivateKey, signaturePublicKey } = await registerDevice({
         vendorIdentity,
@@ -28,7 +28,11 @@ export default async (
         signaturePublicKey,
     })
 
-    const buffer = protoDelimited.enc(provisionData)
+    const buffer = Buffer.from(protoDelimited.enc(provisionData))
 
-    outputBuffer(buffer, format, provisioningFile)
+    outputBuffer(buffer, format, provisioningFile, {
+        fileHexSize: 512,
+        fileHexCrc16: true,
+        fileHexCrc16Magic: true,
+    })
 }

package/lib/createProvisioningData/index.js

@@ -13,36 +13,36 @@ program
     .addOption(
         new Option(
             '--vendorIdentity [vendorIdentity]',
-            'The vendor identity to be used for authentication or "test" for test-data'
-        ).makeOptionMandatory(true)
+            'The vendor identity to be used for authentication or "test" for test-data',
+        ).makeOptionMandatory(true),
     )
     .addOption(
         new Option('--hardwareType [hardwareType]', 'The type of the device')
             .choices(Object.values(BlueHardwareType).filter((x) => typeof x === 'string'))
-            .makeOptionMandatory(true)
+            .makeOptionMandatory(true),
     )
     .addOption(
         new Option(
             '--hardwareVersion [hardwareVersion]',
-            'The actual hardware version of the device which is vendor specific'
-        )
+            'The actual hardware version of the device which is vendor specific',
+        ),
     )
     .addOption(
         new Option(
             '--hardwareSerialNumber [hardwareSerialNumber]',
-            'The vendor serial number for the device which is vendor specific'
-        ).makeOptionMandatory(true)
+            'The vendor serial number for the device which is vendor specific',
+        ).makeOptionMandatory(true),
     )
     .addOption(
         new Option(
             '--hardwareName [hardwareName]',
-            'The human readable identifier of the device which is vendor specific'
-        ).makeOptionMandatory(true)
+            'The human readable identifier of the device which is vendor specific',
+        ).makeOptionMandatory(true),
     )
     .addOption(new Option('--meta [meta]', 'Optional meta data in JSON format for the device'))
     .addOption(
         new Option('--format [format]', 'The output format to be used')
-            .choices(['file'].concat(outputFormats))
-            .makeOptionMandatory()
+            .choices(['file', 'file_hex'].concat(outputFormats))
+            .makeOptionMandatory(),
     )
     .action(action)

package/lib/proto/BlueCore_pb.js

@@ -350,7 +350,7 @@ export const BlueLocalTimeSchedule = proto2.makeMessageType(
   () => [
     { no: 1, name: "dayOfYearStart", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
     { no: 2, name: "dayOfYearEnd", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
-    { no: 3, name: "weekdays", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
+    { no: 3, name: "weekdays", kind: "scalar", T: 8 /* ScalarType.BOOL */, repeated: true },
     { no: 4, name: "timePeriod", kind: "message", T: BlueLocalTimeperiod },
   ],
 );
@@ -386,6 +386,7 @@ export const BlueBleManufacturerInfo = proto2.makeMessageType(
     { no: 2, name: "batteryLevel", kind: "enum", T: proto2.getEnumType(BlueBatteryLevel) },
     { no: 3, name: "applicationVersion", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
     { no: 4, name: "localMidnightTimeEpoch", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 5, name: "isFactory", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
   ],
 );
 
@@ -439,10 +440,10 @@ export const BlueSPHandshakeReply = proto2.makeMessageType(
 );
 
 /**
- * @generated from message BlueSPDataCommand
+ * @generated from message BlueSPTokenCommand
  */
-export const BlueSPDataCommand = proto2.makeMessageType(
-  "BlueSPDataCommand",
+export const BlueSPTokenCommand = proto2.makeMessageType(
+  "BlueSPTokenCommand",
   () => [
     { no: 1, name: "credentialId", kind: "message", T: BlueCredentialId },
     { no: 2, name: "validityStart", kind: "message", T: BlueLocalTimestamp },
@@ -453,13 +454,13 @@ export const BlueSPDataCommand = proto2.makeMessageType(
 );
 
 /**
- * @generated from message BlueSPData
+ * @generated from message BlueSPToken
  */
-export const BlueSPData = proto2.makeMessageType(
-  "BlueSPData",
+export const BlueSPToken = proto2.makeMessageType(
+  "BlueSPToken",
   () => [
     { no: 1, name: "signature", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
-    { no: 2, name: "command", kind: "message", T: BlueSPDataCommand, oneof: "payload" },
+    { no: 2, name: "command", kind: "message", T: BlueSPTokenCommand, oneof: "payload" },
     { no: 3, name: "ossSo", kind: "message", T: BlueOssSoMobile, oneof: "payload" },
     { no: 4, name: "ossSid", kind: "message", T: BlueOssSidMobile, oneof: "payload" },
   ],
@@ -695,7 +696,7 @@ export const BlueOssSoCredentialType = proto2.makeMessageType(
 export const BlueOssSoDTScheduleDay = proto2.makeMessageType(
   "BlueOssSoDTScheduleDay",
   () => [
-    { no: 1, name: "weekdays", kind: "scalar", T: 8 /* ScalarType.BOOL */, repeated: true },
+    { no: 3, name: "weekdays", kind: "scalar", T: 8 /* ScalarType.BOOL */, repeated: true },
     { no: 8, name: "timePeriods", kind: "message", T: BlueLocalTimeperiod, repeated: true },
   ],
 );

package/lib/proto/BlueSystem_pb.js

@@ -7,38 +7,16 @@ import { proto2 } from "@bufbuild/protobuf";
 import { BlueBatteryLevel, BlueBlacklistEntry, BlueEvent, BlueHardwareType, BlueLocalTimeSchedule, BlueLocalTimestamp } from "./BlueCore_pb.js";
 import { BlueLockConfig, BlueLockStatus } from "./BlueLock_pb.js";
 
-/**
- * @generated from enum BlueOnlineMode
- */
-export const BlueOnlineMode = proto2.makeEnum(
-  "BlueOnlineMode",
-  [
-    {no: 0, name: "OfflineMode"},
-    {no: 1, name: "ManualWifi"},
-    {no: 2, name: "AlwaysOnWifi"},
-    {no: 3, name: "UseLan"},
-  ],
-);
-
-/**
- * @generated from message BlueTimeOffsetPeriod
- */
-export const BlueTimeOffsetPeriod = proto2.makeMessageType(
-  "BlueTimeOffsetPeriod",
-  () => [
-    { no: 1, name: "epoch", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
-    { no: 2, name: "offset", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
-  ],
-);
-
 /**
  * @generated from message BlueBaseConfig
  */
 export const BlueBaseConfig = proto2.makeMessageType(
   "BlueBaseConfig",
   () => [
-    { no: 1, name: "timeOffsetPeriods", kind: "message", T: BlueTimeOffsetPeriod, repeated: true },
-    { no: 2, name: "autoCheckSystemStatus", kind: "scalar", T: 8 /* ScalarType.BOOL */, default: false },
+    { no: 1, name: "isoCountry", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "isoState", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "utcOffsetMinutes", kind: "scalar", T: 5 /* ScalarType.INT32 */, default: 0 },
+    { no: 4, name: "autoCheckSystemStatus", kind: "scalar", T: 8 /* ScalarType.BOOL */, default: false },
   ],
 );
 
@@ -65,11 +43,21 @@ export const BlueBleConfig = proto2.makeMessageType(
 export const BlueOnlineConfig = proto2.makeMessageType(
   "BlueOnlineConfig",
   () => [
-    { no: 1, name: "mode", kind: "enum", T: proto2.getEnumType(BlueOnlineMode), default: BlueOnlineMode.OfflineMode },
-    { no: 2, name: "connectSchedules", kind: "message", T: BlueLocalTimeSchedule, repeated: true },
-    { no: 3, name: "wifiSSID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 4, name: "wifiPassword", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 5, name: "timeoutSec", kind: "scalar", T: 13 /* ScalarType.UINT32 */, default: 30 },
+    { no: 1, name: "connectSchedules", kind: "message", T: BlueLocalTimeSchedule, repeated: true },
+    { no: 2, name: "wifiSSID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "wifiPassword", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "timeoutSec", kind: "scalar", T: 13 /* ScalarType.UINT32 */, default: 30 },
+  ],
+);
+
+/**
+ * @generated from message BlueAccessConfigGroup
+ */
+export const BlueAccessConfigGroup = proto2.makeMessageType(
+  "BlueAccessConfigGroup",
+  () => [
+    { no: 1, name: "groupId", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "schedules", kind: "message", T: BlueLocalTimeSchedule, repeated: true },
   ],
 );
 
@@ -81,7 +69,7 @@ export const BlueAccessConfig = proto2.makeMessageType(
   () => [
     { no: 1, name: "id", kind: "scalar", T: 13 /* ScalarType.UINT32 */, default: 1 },
     { no: 2, name: "siteId", kind: "scalar", T: 13 /* ScalarType.UINT32 */, default: 1 },
-    { no: 3, name: "groupIds", kind: "scalar", T: 13 /* ScalarType.UINT32 */, repeated: true },
+    { no: 3, name: "groups", kind: "message", T: BlueAccessConfigGroup, repeated: true },
   ],
 );
 
@@ -112,7 +100,7 @@ export const BlueOssConfig = proto2.makeMessageType(
 export const BlueSystemConfig = proto2.makeMessageType(
   "BlueSystemConfig",
   () => [
-    { no: 1, name: "version", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 1, name: "configId", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 2, name: "base", kind: "message", T: BlueBaseConfig },
     { no: 3, name: "ble", kind: "message", T: BlueBleConfig },
     { no: 4, name: "online", kind: "message", T: BlueOnlineConfig },
@@ -184,7 +172,7 @@ export const BlueSystemProvisioning = proto2.makeMessageType(
 export const BlueSystemStatus = proto2.makeMessageType(
   "BlueSystemStatus",
   () => [
-    { no: 1, name: "configVersion", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 1, name: "configId", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 2, name: "deviceId", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 3, name: "serialNumber", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 4, name: "hardwareType", kind: "enum", T: proto2.getEnumType(BlueHardwareType) },

package/lib/shared/binaryToIntelHex.js

@@ -0,0 +1,246 @@
+// From https://en.wikipedia.org/wiki/Intel_HEX
+//
+//		Intel Hex Line Format (I32HEX, 32 bit addresses) is
+//          :llaaaatt[dd...]cc
+//		Where
+//          ll=data length
+//		    aaaa=lower 16 bit address
+//		    tt=record type
+//			    00 - data record
+//              01 - end-of-file record
+//              02 - extended segment address record (Not used in I32Hex)
+//              04 - extended linear address record
+//              05 - start linear address record (MDK-ARM only)
+//		    cc=checksum = 2's comp of negative of sum of all record bytes
+
+var DEFAULT_LINE_TERMINATOR = '\n'
+var SEGMENT_LENGTH_BYTES = 0x10000
+var MAX_BASE_ADDRESS = 0xffff
+
+const utils = {
+    numberToHexString: function (d, padding) {
+        var hex = Number(d).toString(16).toUpperCase()
+        padding = typeof padding === 'undefined' || padding === null ? (padding = 8) : padding
+
+        while (hex.length < padding) {
+            hex = '0' + hex
+        }
+
+        return hex
+    },
+    numberToHexStringLittleEndian: function (d, padding) {
+        if (padding % 2 != 0)
+            throw new Error('numberToHexStringLittleEndian requires an even padding [' + padding + ']')
+
+        var bigEndianHex = utils.numberToHexString(d, padding)
+
+        var littleEndianHex = ''
+        while (bigEndianHex.length) {
+            var nibble = bigEndianHex[0] + bigEndianHex[1]
+            bigEndianHex = bigEndianHex.slice(2)
+            littleEndianHex = nibble + littleEndianHex
+        }
+
+        return littleEndianHex
+    },
+    hexStringByWords: function (hex, littleEndian) {
+        if (!hex || hex.length % 8 !== 0) throw new Error('hexStringByWords requires a word-aligned hex string')
+        littleEndian = !!littleEndian
+
+        hex = hex.toUpperCase()
+        const wordStrings = []
+
+        for (var i = 0; i < hex.length; i += 8) {
+            var ws = hex.substring(i, i + 8)
+            if (littleEndian) {
+                ws = ws.substring(6, 8) + ws.substring(4, 6) + ws.substring(2, 4) + ws.substring(0, 2)
+            }
+            wordStrings.push(ws)
+        }
+
+        return wordStrings.join(' ')
+    },
+    hexToDecimal: function (hexString) {
+        try {
+            return parseInt(hexString, 16)
+        } catch (e) {
+            console.error('Error parsing hexString: ', e)
+            return 0
+        }
+    },
+    toUInt32: function (val) {
+        return val >>> 0
+    },
+}
+
+function IntelHexFileOut(startAddress) {
+    if (startAddress === void 0) startAddress = 0
+
+    this.contents = ''
+    this.extendedAddress = 0
+    this.relativeAddress = 0
+    this.lastAppendEndedAtBoundary = false
+    this.lineTerminator = DEFAULT_LINE_TERMINATOR
+
+    this.setAddress(startAddress)
+}
+
+IntelHexFileOut.withIntelHex = function (initialHexString, startAddress) {
+    const intelhexProcessor = new IntelHexFileOut(startAddress)
+    intelhexProcessor.contents = initialHexString.toUpperCase()
+    intelhexProcessor.reopen()
+    return intelhexProcessor
+}
+
+IntelHexFileOut.prototype.reopen = function () {
+    const indexOfTerminator = this.contents.indexOf(this.eofMarker())
+    if (indexOfTerminator !== -1) {
+        this.contents = this.contents.substring(0, indexOfTerminator)
+    }
+}
+
+IntelHexFileOut.prototype.eofMarker = function () {
+    return ':00000001FF' + this.lineTerminator
+}
+
+IntelHexFileOut.prototype.setAddress = function (address) {
+    var extendedAddress = this._extendedAddressFromAddress(address)
+    this.relativeAddress = this._addressRelativeToExtendedAddress(address, extendedAddress)
+
+    if (this.extendedAddress === extendedAddress) return
+    this.extendedAddress = extendedAddress
+
+    this._writeExtendedAddress()
+
+    this.lastAppendEndedAtBoundary = false
+}
+
+IntelHexFileOut.prototype.writeHexStringAtAddress = function (address, hexString) {
+    if (!hexString || hexString.length === 0 || hexString.length > SEGMENT_LENGTH_BYTES || hexString.length % 2 !== 0) {
+        throw new Error('invalid length of hexString [' + hexString.length + ']')
+    }
+
+    this.setAddress(address)
+    this.appendHexString(hexString)
+}
+
+IntelHexFileOut.prototype.appendBuffer = function (buffer, littleEndian) {
+    if (!buffer) throw new Error('Buffer required')
+    if (buffer.length % 4 !== 0) throw new Error('Buffer length not 32 bit word aligned')
+
+    const words = []
+    for (var offset = 0; offset < buffer.length; offset += 4) {
+        const uint32 = littleEndian ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset)
+        words.push(uint32)
+    }
+
+    this.appendWords(words, littleEndian)
+}
+
+IntelHexFileOut.prototype.appendWords = function (words, littleEndian) {
+    if (!words || words.length === 0) {
+        // || words.length * 4 > SEGMENT_LENGTH_BYTES ){
+        throw new Error('invalid number of words [' + words.length + ']')
+    }
+
+    var encodeAsString = littleEndian ? utils.numberToHexStringLittleEndian : utils.numberToHexString
+
+    var lineHexString = ''
+    while (words.length) {
+        lineHexString += encodeAsString(words.shift(), 8)
+        if (lineHexString.length === 32) {
+            this.appendHexString(lineHexString)
+            lineHexString = ''
+        }
+    }
+
+    if (lineHexString.length) {
+        this.appendHexString(lineHexString)
+    }
+}
+
+IntelHexFileOut.prototype.appendHexString = function (hexString) {
+    if (!hexString || hexString.length === 0 || hexString.length > SEGMENT_LENGTH_BYTES || hexString.length % 2 !== 0) {
+        throw new Error('invalid length of hexString [' + hexString.length + ']')
+    }
+
+    while (hexString.length) {
+        var lineHexCharLength = hexString.length < 32 ? hexString.length : 32
+        var lineHexString = hexString.slice(0, lineHexCharLength)
+
+        hexString = hexString.slice(lineHexCharLength)
+
+        this._handleBlockContinuation()
+
+        var byteCount = lineHexString.length / 2
+
+        if (this.relativeAddress + byteCount > 0x10000) {
+            throw new Error('appendHexString cannot write across 63336 byte boundary')
+        }
+
+        this._writeHexString(lineHexString)
+
+        this.relativeAddress += byteCount
+        if (this.relativeAddress == SEGMENT_LENGTH_BYTES) {
+            this.extendedAddress += 0x0001
+            this.relativeAddress = 0x0000
+            this.lastAppendEndedAtBoundary = true
+        }
+    }
+}
+
+IntelHexFileOut.prototype.close = function () {
+    this.contents += this.eofMarker()
+}
+
+IntelHexFileOut.prototype._writeExtendedAddress = function () {
+    var data = this.extendedAddress
+    var intelHex = '02' + '0000' + '04' + utils.numberToHexString(data, 4)
+    intelHex += this._crc(intelHex)
+    this.contents += ':' + intelHex + this.lineTerminator
+}
+
+IntelHexFileOut.prototype._writeHexString = function (hexString) {
+    var byteCount = hexString.length / 2
+    var intelHex =
+        utils.numberToHexString(byteCount, 2) + utils.numberToHexString(this.relativeAddress, 4) + '00' + hexString
+    intelHex += this._crc(intelHex)
+    this.contents += ':' + intelHex + this.lineTerminator
+}
+
+IntelHexFileOut.prototype._handleBlockContinuation = function () {
+    if (this.lastAppendEndedAtBoundary) {
+        this._writeExtendedAddress()
+        this.lastAppendEndedAtBoundary = false
+    }
+}
+
+IntelHexFileOut.prototype._crc = function (intelHexString) {
+    var sum = 0
+    for (var i = 0; i < intelHexString.length; i += 2) {
+        var byteHexString = intelHexString.charAt(i) + intelHexString.charAt(i + 1)
+        sum += utils.hexToDecimal(byteHexString) & 0xff
+    }
+    var crc = ((sum ^ 0xff) + 1) & 0xff
+    return utils.numberToHexString(crc, 2)
+}
+
+IntelHexFileOut.prototype._extendedAddressFromAddress = function (address) {
+    return address >>> 16
+}
+
+IntelHexFileOut.prototype._addressRelativeToExtendedAddress = function (address, extendedAddress) {
+    var baseAddress = utils.toUInt32(extendedAddress << 16)
+    if (address < baseAddress || address - baseAddress > MAX_BASE_ADDRESS) {
+        throw new Error('address must be 0 to 65535 bytes above baseAddress [' + baseAddress + ']')
+    }
+
+    return address - baseAddress
+}
+
+export default (startAddress, littleEndian, buffer) => {
+    var processor = new IntelHexFileOut(startAddress)
+    processor.appendBuffer(buffer, littleEndian)
+    processor.close()
+    return processor.contents
+}

package/lib/shared/crc16.js

@@ -0,0 +1,26 @@
+const STORAGE_CRC_16_MAGIC_NUMBER = 0x92db
+
+export default (buffer, start, magicMarker = false) => {
+    // CRC-16-CCITT (XModem)
+    const crcTable = [
+        0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad,
+        0xe1ce, 0xf1ef,
+    ]
+
+    let crc = 0xffff
+
+    const data = new Uint8Array(buffer)
+
+    for (let i = start; i < data.length; i++) {
+        crc = (crc << 4) ^ crcTable[((crc >>> 12) ^ data[i]) & 0x0f]
+        crc = (crc << 4) ^ crcTable[((crc >>> 12) ^ (data[i] >>> 4)) & 0x0f]
+    }
+
+    if (magicMarker) {
+        crc ^= STORAGE_CRC_16_MAGIC_NUMBER
+    }
+
+    crc &= 0xffff
+
+    return crc
+}

package/lib/shared/outputBuffer.js

@@ -1,6 +1,9 @@
 import path from 'path'
 import fs from 'fs'
 
+import binaryToIntelHex from './binaryToIntelHex.js'
+import crc16 from './crc16.js'
+
 const bufferToCArray = (buffer) => {
     const hexString = buffer.toString('hex')
     const hexArray = hexString.match(/.{1,2}/g)
@@ -13,9 +16,41 @@ const bufferToProtoArray = (buffer) => {
     return hexArray.map((hex) => `\\x${hex}`).join('')
 }
 
+const bufferToIntelHex = (buffer, hexStartAddress, hexSize, hexCrc16, hexCrc16Magic) => {
+    if (typeof hexStartAddress !== 'number') {
+        throw new Error('Invalid hexStartAddress')
+    }
+
+    if (typeof hexSize !== 'number') {
+        throw new Error('Invalid hexSize')
+    }
+
+    if (typeof hexCrc16 !== 'boolean') {
+        throw new Error('Invalid hexCrc16')
+    }
+
+    if (typeof hexCrc16Magic !== 'boolean') {
+        throw new Error('Invalid hexCrc16Magic')
+    }
+
+    const binaryBuffer = Buffer.alloc(hexSize)
+
+    if (hexCrc16) {
+        buffer.copy(binaryBuffer, 2, 0)
+        const crc16_ = crc16(binaryBuffer, 2, hexCrc16Magic)
+        binaryBuffer.writeUInt16LE(crc16_, 0)
+        console.log(`Intel Hex, startAddress=${hexStartAddress}, size=${hexSize}, crc16=${crc16_}`)
+    } else {
+        buffer.copy(binaryBuffer, 0, 0)
+        console.log(`Intel Hex, startAddress=${hexStartAddress}, size=${hexSize}`)
+    }
+
+    return binaryToIntelHex(hexStartAddress, true, binaryBuffer)
+}
+
 export const outputFormats = ['hex', 'cpphex', 'protohex', 'base64']
 
-export default (buffer, format, filename) => {
+export default (buffer, format, filename, settings = {}) => {
     let result = null
 
     switch (format) {
@@ -31,13 +66,34 @@ export default (buffer, format, filename) => {
         case 'base64':
             result = buffer.toString('base64')
             break
-        default:
+        case 'file':
             {
                 const filepath = path.resolve(filename)
                 fs.writeFileSync(filepath, buffer)
                 result = `Written to file <${filepath}>`
             }
             break
+        case 'file_hex':
+            {
+                const [startAddress, filename_] = filename.split(':')
+
+                const startAddressNo = Number.parseInt(startAddress)
+                if (Number.isNaN(startAddressNo)) {
+                    throw new Error(`Invalid startAddress ${startAddress}`)
+                }
+
+                const { fileHexSize, fileHexCrc16, fileHexCrc16Magic } = settings
+
+                const hexData = bufferToIntelHex(buffer, startAddressNo, fileHexSize, fileHexCrc16, fileHexCrc16Magic)
+
+                const filepath = path.resolve(filename_)
+                fs.writeFileSync(filepath, hexData)
+
+                result = `Written to file <${filepath}>`
+            }
+            break
+        default:
+            throw new Error(`Unknown format ${format}`)
     }
 
     console.log(`(${format} with ${buffer.length.toString()} bytes)\n`)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@blueid/access-cli",
-    "version": "0.21.0",
+    "version": "0.22.0",
     "description": "BlueID Access CLI",
     "type": "module",
     "main": "./index.js",
@@ -14,7 +14,7 @@
         "package.json"
     ],
     "scripts": {
-        "sync-proto": "sh syncproto.sh",
+        "sync-proto": "sh syncproto.sh || exit 0",
         "preinstall": "npm run sync-proto",
         "prepack": "npm run sync-proto"
     },