You can use Buffer.from(str, [encoding]) to perform the conversion.

Buffer.from(str, 'hex');

In new versions of node (6+) the new Buffer() interface is deprecated. Use:

Buffer.from("250001000192CD0000002F6D6E742F72", "hex")

instead.

Find more info on this using this link below https://nodejs.org/api/buffer.html#buffer_static_method_buffer_from_string_encoding

Here's a node.js specific approach, taking advantage of the the Buffer class provided by the node standard lib.

https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings

To get the byte (0-255) value:

Buffer.from('80', 'hex')[0];
// outputs 128

And to convert back:

Buffer.from([128]).toString('hex');
// outputs '80'

To convert to utf8:

Buffer.from('80', 'hex').toString('utf8');

Convert a hex string to a byte array and vice versa

note: implementation from crypto-js, though now out of date and slightly altered

// Convert a hex string to a byte array
function hexToBytes(hex) {
    let bytes = [];
    for (let c = 0; c < hex.length; c += 2)
        bytes.push(parseInt(hex.substr(c, 2), 16));
    return bytes;
}

// Convert a byte array to a hex string
function bytesToHex(bytes) {
    let hex = [];
    for (let i = 0; i < bytes.length; i++) {
        let current = bytes[i] < 0 ? bytes[i] + 256 : bytes[i];
        hex.push((current >>> 4).toString(16));
        hex.push((current & 0xF).toString(16));
    }
    return hex.join("");
}

You are missing the padding in the hex conversion. You'll want to use

function toHexString(byteArray) {
  return Array.from(byteArray, function(byte) {
    return ('0' + (byte & 0xFF).toString(16)).slice(-2);
  }).join('')
}

so that each byte transforms to exactly two hex digits. Your expected output would be 04812d7e3a9829e5d51bdd64ceb35df060699bc1309731bd6e6f1a5443a7f9ce0af4382fcfd6f5f8a08bb2619709c2d49fb771601770f2c267985af2754e1f8cf9

I'm not sure this is what you're after, but you can convert the string to an array of hex values like this:

var str = "00010203040506070809",
    a = [];

for (var i = 0; i < str.length; i += 2) {
    a.push("0x" + str.substr(i, 2));
}

console.log(a); // prints the array
console.log(a.join(" ")); // turn the array into a string of hex values
​console.log(parseInt(a[1], 16));​ // parse a particular hex number to a decimal value

Further, you cannot simply push a value of type Integer to a byte array. Integers are represented with 32 bit (4 bytes), so you first have to "split" such number while computing the single bytes one by one:

intToByteArray = function(intToConvert) {
    var byteArray = new Array(4)

    for(var i = 0; i < byteArray.length; i++) {
        var byte = intToConvert & 0xff;
        byteArray[i] = byte;
        intToConvert = (intToConvert - byte) / 256 ;
    }

    return byteArray;
};     

Demonstration of back and forth conversion (JS-Fiddle)

Explanation of code lines

1. At first, we declare an array of bytes:

   var byteArray = new Array(4)
   

   Array: [00000000, 00000000, 00000000, 00000000]

2. By using the bit-wise AND operator &, we "capture" the first 8 bits while assigning the resulting value to a new variable:

   var byte = intToConvert & 0xff;
   

   What's happening with our variables:

   intToConvert: 10101010 10101010 10101010 10101010
   
   AND "0xff":   11111111 -------- -------- --------
   
   Results in:   10101010
   

3. Then, we put the resulting single byte to the actual index of the temporary byte array:

   byteArray[i] = byte;
   

   Array: [10101010, 00000000, 00000000, 00000000]

4. Now, we only have to subtract the value just added to the array and remove one byte from the integer variable:

   intToConvert = (intToConvert - byte) / 256 ;
   

   2863311530 - 170 = 2863311360
   2863311360 / 256 = 11184810

   2863311360 => 10101010 10101010 10101010 00000000
     11184810 =>          10101010 10101010 10101010
   

Continuing with this loop will transfer byte by byte from the Integer to the temporary byte array. So we will get a byte array of 4 single bytes representing one integer or two Character of the hexadecimal String.

How to convert byte to Integer is well explained here.
So your updated hex2bin(String) should look like:

function hex2bin(hexString) {
    var bytes = new Array(hexString.length / 2);

    for(var i = 0; i < hexString.length-1; i+=2) {
        bytes.push(
            intToByteArray(
                parseInt(hexString.substr(i, 2), 16)
            )
        );
    }

    StringBuilder sb = new StringBuilder(bytes.length * 8);
    for(byte b : bytes) {
        sb.append(Integer.toBinaryString((b & 0xFF) + 0x100).substring(1));    
    }
    return sb.toString();
}

A single liner :

   '[86400:?]'.split ('').map (function (c) { return c.charCodeAt (0); })

returns

    [91, 56, 54, 52, 48, 48, 58, 63, 93]

This is, of course, is an array of numbers, not strictly a "byte array". Did you really mean a "byte array"?

Split the string into individual characters then map each character to its numeric code.

Per your added information about device.write I found this :

Writing to a device

Writing to a device is performed using the write call in a device handle. All writing is synchronous.

device.write([0x00, 0x01, 0x01, 0x05, 0xff, 0xff]);

on https://npmjs.org/package/node-hid

Assuming this is what you are using then my array above would work perfectly well :

device.write('[86400:?]'.split ('').map (function (c) { return c.charCodeAt (0); }));

As has been noted the 0x notation is just that, a notation. Whether you specify 0x0a or 10 or 012 (in octal) the value is the same.