@basmilius/apple-companion-link 0.0.3 → 0.0.5

package/src/encoding/opack.ts

@@ -1,293 +0,0 @@
-type Packed = Uint8Array;
-type ObjectList = Packed[];
-
-class SizedInt extends Number {
-    size: number;
-
-    constructor(value: number, size: number) {
-        super(value);
-        this.size = size;
-    }
-}
-
-const _SIZED_INT_TYPES: Record<number, typeof SizedInt> = {};
-
-export function sizedInt(value: number, size: number): SizedInt {
-    return new SizedInt(value, size);
-}
-
-class OPACKFloat {
-    value: number;
-
-    constructor(value: number) {
-        this.value = value;
-    }
-}
-
-export function float(value: number) {
-    return new OPACKFloat(value);
-}
-
-class OPACKInt {
-    value: number;
-
-    constructor(value: number) {
-        this.value = value;
-    }
-}
-
-export function int(value: number) {
-    return new OPACKInt(value);
-}
-
-function concat(arr: Uint8Array[]): Uint8Array {
-    const total = arr.reduce((s, a) => s + a.length, 0);
-    const out = new Uint8Array(total);
-    let off = 0;
-    for (const a of arr) {
-        out.set(a, off);
-        off += a.length;
-    }
-    return out;
-}
-
-function u8(b: number) {
-    return Uint8Array.of(b);
-}
-
-function uintToLEBytes(value: number | bigint, byteLen: number): Uint8Array {
-    const out = new Uint8Array(byteLen);
-    let v = BigInt(value);
-    for (let i = 0; i < byteLen; i++) {
-        out[i] = Number(v & 0xffn);
-        v >>= 8n;
-    }
-    return out;
-}
-
-function concatUint8Arrays(arrays: Uint8Array[]): Uint8Array {
-    const total = arrays.reduce((sum, a) => sum + a.length, 0);
-    const out = new Uint8Array(total);
-    let offset = 0;
-    for (const a of arrays) {
-        out.set(a, offset);
-        offset += a.length;
-    }
-    return out;
-}
-
-export function pack(data: any): Uint8Array {
-    return _pack(data, []);
-}
-
-function _pack(data: any, objectList: ObjectList): Uint8Array {
-    let packed: Uint8Array | null = null;
-
-    if (data === null || data === undefined) packed = u8(0x04);
-    else if (typeof data === 'boolean') packed = u8(data ? 0x01 : 0x02);
-    else if (data instanceof OPACKFloat) {
-        const buf = new ArrayBuffer(8);
-        new DataView(buf).setFloat64(0, data.value, true);
-        packed = concat([u8(0x36), new Uint8Array(buf)]);
-    } else if (data instanceof OPACKInt) {
-        const val = data.value;
-        if (val < 0x28) packed = u8(0x08 + val);
-        else if (val <= 0xff) packed = concatUint8Arrays([u8(0x30), uintToLEBytes(val, 1)]);
-        else if (val <= 0xffff) packed = concatUint8Arrays([u8(0x31), uintToLEBytes(val, 2)]);
-        else if (val <= 0xffffffff) packed = concatUint8Arrays([u8(0x32), uintToLEBytes(val, 4)]);
-        else packed = concatUint8Arrays([u8(0x33), uintToLEBytes(val, 8)]);
-    } else if (typeof data === 'number') {
-        if (!Number.isInteger(data)) {
-            const buf = new ArrayBuffer(8);
-            new DataView(buf).setFloat64(0, data, true);
-            packed = concat([u8(0x36), new Uint8Array(buf)]);
-        } else {
-            if (data < 0x28) packed = u8(0x08 + data);
-            else if (data <= 0xff) packed = concat([u8(0x30), uintToLEBytes(data, 1)]);
-            else if (data <= 0xffff) packed = concat([u8(0x31), uintToLEBytes(data, 2)]);
-            else if (data <= 0xffffffff) packed = concat([u8(0x32), uintToLEBytes(data, 4)]);
-            else packed = concat([u8(0x33), uintToLEBytes(data, 8)]);
-        }
-    } else if (data instanceof SizedInt) {
-        packed = concat([u8(0x30 + Math.log2(data.size)), uintToLEBytes(data.valueOf(), data.size)]);
-    } else if (typeof data === 'string') {
-        const b = new TextEncoder().encode(data);
-        const len = b.length;
-        if (len <= 0x20) packed = concat([u8(0x40 + len), b]);
-        else if (len <= 0xff) packed = concat([u8(0x61), uintToLEBytes(len, 1), b]);
-        else if (len <= 0xffff) packed = concat([u8(0x62), uintToLEBytes(len, 2), b]);
-        else if (len <= 0xffffff) packed = concat([u8(0x63), uintToLEBytes(len, 3), b]);
-        else packed = concat([u8(0x64), uintToLEBytes(len, 4), b]);
-    } else if (data instanceof Uint8Array || Buffer.isBuffer(data)) {
-        const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
-        const len = bytes.length;
-        if (len <= 0x20) packed = concat([u8(0x70 + len), bytes]);
-        else if (len <= 0xff) packed = concat([u8(0x91), uintToLEBytes(len, 1), bytes]);
-        else if (len <= 0xffff) packed = concat([u8(0x92), uintToLEBytes(len, 2), bytes]);
-        else packed = concat([u8(0x93), uintToLEBytes(len, 4), bytes]);
-    } else if (Array.isArray(data)) {
-        const body = concat(data.map(d => _pack(d, objectList)));
-        const len = data.length;
-        if (len <= 0x0f) {
-            packed = concat([u8(0xd0 + len), body]);
-            if (len >= 0x0f) packed = concat([packed, u8(0x03)]);
-        } else packed = concat([u8(0xdf), body, u8(0x03)]);
-    } else if (typeof data === 'object') {
-        const keys = Object.keys(data);
-        const len = keys.length;
-        const pairs: Uint8Array[] = [];
-        for (const k of keys) {
-            pairs.push(_pack(k, objectList));
-            pairs.push(_pack((data as any)[k], objectList));
-        }
-        let header: Uint8Array;
-        if (len <= 0x0f) {
-            header = u8(0xE0 + len);
-        } else {
-            header = u8(0xEF);
-        }
-        packed = concatUint8Arrays([header, concatUint8Arrays(pairs)]);
-        // terminator
-        if (len >= 0x0f || objectList.some(v => v === packed)) {
-            packed = concatUint8Arrays([packed, u8(0x81)]);
-        }
-    } else throw new TypeError(typeof data + '');
-
-    // Object reuse
-    const idx = objectList.findIndex(v => v.length === packed!.length && v.every((x, i) => x === packed![i]));
-    if (idx >= 0) {
-        if (idx < 0x21) packed = u8(0xA0 + idx);
-        else if (idx <= 0xff) packed = concat([u8(0xC1), uintToLEBytes(idx, 1)]);
-        else if (idx <= 0xffff) packed = concat([u8(0xC2), uintToLEBytes(idx, 2)]);
-        else if (idx <= 0xffffffff) packed = concat([u8(0xC3), uintToLEBytes(idx, 4)]);
-        else packed = concat([u8(0xC4), uintToLEBytes(idx, 8)]);
-    } else if (packed!.length > 1) objectList.push(packed!);
-
-    return packed!;
-}
-
-/* UNPACK */
-export function unpack(data: Uint8Array): [any, Uint8Array] {
-    return _unpack(data, []);
-}
-
-function _unpack(data: Uint8Array, objectList: ObjectList): [any, Uint8Array] {
-    if (data.length === 0) throw new TypeError('No data to unpack');
-    let addToObjectList = true;
-    const tag = data[0];
-
-    // simple tokens
-    if (tag === 0x01) return [true, data.subarray(1)];
-    if (tag === 0x02) return [false, data.subarray(1)];
-    if (tag === 0x04) return [null, data.subarray(1)];
-    if (tag === 0x05) {
-        const uuidBytes = data.subarray(1, 17);
-        return [uuidBytes, data.subarray(17)];
-    }
-    if (tag === 0x06) {
-        // pyatv: dummy parse as integer (little-endian 8 bytes)
-        const val = readLittleEndian(data, 1, 8);
-        return [val, data.subarray(9)];
-    }
-    if (tag >= 0x08 && tag <= 0x2f) return [tag - 8, data.subarray(1)];
-    if (tag === 0x35) {
-        const view = new DataView(data.buffer, data.byteOffset + 1, 4);
-        return [view.getFloat32(0, true), data.subarray(5)];
-    }
-    if (tag === 0x36) {
-        const view = new DataView(data.buffer, data.byteOffset + 1, 8);
-        return [view.getFloat64(0, true), data.subarray(9)];
-    }
-    if ((tag & 0xF0) === 0x30) {
-        const noOfBytes = 2 ** (tag & 0xF);
-        const val = readLittleEndian(data, 1, noOfBytes);
-        const sized = sizedInt(val, noOfBytes);
-        return [sized, data.subarray(1 + noOfBytes)];
-    }
-    if (tag >= 0x40 && tag <= 0x60) {
-        const length = tag - 0x40;
-        const str = new TextDecoder().decode(data.subarray(1, 1 + length));
-        return [str, data.subarray(1 + length)];
-    }
-    if (tag >= 0x61 && tag <= 0x64) {
-        const lenBytes = tag & 0xF;
-        const length = readLittleEndian(data, 1, lenBytes);
-        const str = new TextDecoder().decode(data.subarray(1 + lenBytes, 1 + lenBytes + length));
-        return [str, data.subarray(1 + lenBytes + length)];
-    }
-    if (tag >= 0x70 && tag <= 0x90) {
-        const length = tag - 0x70;
-        const bytes = data.subarray(1, 1 + length);
-        return [bytes, data.subarray(1 + length)];
-    }
-    if (tag >= 0x91 && tag <= 0x94) {
-        // number of length bytes = 1 << ((tag & 0xF) - 1)
-        const noOfBytes = 1 << ((tag & 0xF) - 1);
-        const length = readLittleEndian(data, 1, noOfBytes);
-        const start = 1 + noOfBytes;
-        return [data.subarray(start, start + length), data.subarray(start + length)];
-    }
-    if ((tag & 0xF0) === 0xD0) {
-        const count = tag & 0xF;
-        let ptr = data.subarray(1);
-        const output: any[] = [];
-        if (count === 0xF) {
-            // endless list
-            while (ptr[0] !== 0x03) {
-                const [val, rem] = _unpack(ptr, objectList);
-                output.push(val);
-                ptr = rem;
-            }
-            ptr = ptr.subarray(1); // skip terminator
-        } else {
-            for (let i = 0; i < count; i++) {
-                const [val, rem] = _unpack(ptr, objectList);
-                output.push(val);
-                ptr = rem;
-            }
-        }
-        addToObjectList = false;
-        return [output, ptr];
-    }
-    if ((tag & 0xE0) === 0xE0) {
-        const count = tag & 0xF;
-        let ptr = data.subarray(1);
-        const output: Record<string, any> = {};
-        if (count === 0xF) {
-            // endless dict
-            while (ptr[0] !== 0x03) {
-                const [key, rem1] = _unpack(ptr, objectList);
-                const [val, rem2] = _unpack(rem1, objectList);
-                output[key] = val;
-                ptr = rem2;
-            }
-            ptr = ptr.subarray(1);
-        } else {
-            for (let i = 0; i < count; i++) {
-                const [key, rem1] = _unpack(ptr, objectList);
-                const [val, rem2] = _unpack(rem1, objectList);
-                output[key] = val;
-                ptr = rem2;
-            }
-        }
-        addToObjectList = false;
-        return [output, ptr];
-    }
-    if (tag >= 0xA0 && tag <= 0xC0) {
-        const idx = tag - 0xA0;
-        return [objectList[idx], data.subarray(1)];
-    }
-    if (tag >= 0xC1 && tag <= 0xC4) {
-        const len = tag - 0xC0;
-        const uid = readLittleEndian(data, 1, len);
-        return [objectList[uid], data.subarray(1 + len)];
-    }
-
-    throw new TypeError(`Unknown tag 0x${tag.toString(16)}`);
-}
-
-function readLittleEndian(buf: Uint8Array, offset: number, len: number) {
-    let v = 0n;
-    for (let i = len - 1; i >= 0; i--) v = (v << 8n) | BigInt(buf[offset + i]);
-    return Number(v);
-}

package/src/encoding/plist.ts

@@ -1,2 +0,0 @@
-export { parse } from '@plist/binary.parse';
-export { serialize } from '@plist/binary.serialize';

package/src/encoding/tlv8.ts

@@ -1,111 +0,0 @@
-export const Flags = {
-    TransientPairing: 0x10
-} as const;
-
-export const Method = {
-    PairSetup: 0x00,
-    PairSetupWithAuth: 0x01,
-    PairVerify: 0x02,
-    AddPairing: 0x03,
-    RemovePairing: 0x04,
-    ListPairing: 0x05
-} as const;
-
-export const State = {
-    M1: 0x01,
-    M2: 0x02,
-    M3: 0x03,
-    M4: 0x04,
-    M5: 0x05,
-    M6: 0x06
-} as const;
-
-export const Value = {
-    Method: 0x00,
-    Identifier: 0x01,
-    Salt: 0x02,
-    PublicKey: 0x03,
-    Proof: 0x04,
-    EncryptedData: 0x05,
-    State: 0x06,
-    Error: 0x07,
-    BackOff: 0x08,
-    Certificate: 0x09,
-    Signature: 0x0A,
-    Permissions: 0x0B,
-    FragmentData: 0x0C,
-    FragmentLast: 0x0D,
-
-    Name: 0x11,
-    Flags: 0x13
-} as const;
-
-export function bail(data: Map<number, Buffer>): never {
-    if (data.has(Value.BackOff)) {
-        const buffer = data.get(Value.BackOff);
-        const time = buffer.readUintLE(0, buffer.length);
-
-        throw new Error(`Device is busy, try again in ${time} seconds.`);
-    }
-
-    if (data.has(Value.Error)) {
-        throw new Error(`Device returned an error code: ${data.get(Value.Error).readUint8()}`);
-    }
-
-    console.error(data);
-
-    throw new Error('Invalid response');
-}
-
-export function encode(entries: [number, number | Buffer][]): Buffer {
-    const chunks: number[] = [];
-
-    for (const [type, valueRaw] of entries) {
-        let value: Buffer;
-
-        if (typeof valueRaw === 'number') {
-            value = Buffer.from([valueRaw]);
-        } else {
-            value = valueRaw;
-        }
-
-        let offset = 0;
-
-        do {
-            const len = Math.min(value.length - offset, 255);
-            chunks.push(type, len);
-
-            if (len > 0) {
-                for (let i = 0; i < len; i++) {
-                    chunks.push(value[offset + i]);
-                }
-            }
-
-            offset += len;
-        } while (offset < value.length);
-    }
-
-    return Buffer.from(chunks);
-}
-
-export function decode(buf: Buffer): Map<number, Buffer> {
-    const map = new Map<number, Buffer>();
-    let i = 0;
-
-    while (i < buf.length) {
-        const type = buf[i++];
-        const len = buf[i++];
-
-        const value = (new Uint8Array(buf)).slice(i, i + len);
-        i += len;
-
-        const existing = map.get(type);
-        if (existing) {
-            map.set(type, Buffer.concat([existing, value]));
-        } else {
-            map.set(type, Buffer.from(value));
-        }
-    }
-
-    return map;
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from './discovery';
-export * from './encoding';
-export * from './protocol';

package/src/net/getLocalIP.ts

@@ -1,25 +0,0 @@
-import { networkInterfaces } from 'node:os';
-
-export default function (): string {
-    const interfaces = networkInterfaces();
-
-    for (const name of Object.keys(interfaces)) {
-        const iface = interfaces[name];
-
-        if (!iface) {
-            continue;
-        }
-
-        for (const net of iface) {
-            if (net.internal || net.family !== 'IPv4') {
-                continue;
-            }
-
-            if (net.address && net.address !== '127.0.0.1') {
-                return net.address;
-            }
-        }
-    }
-
-    return null;
-}

package/src/net/getMacAddress.ts

@@ -1,25 +0,0 @@
-import { networkInterfaces } from 'node:os';
-
-export default function (): string {
-    const interfaces = networkInterfaces();
-
-    for (const name of Object.keys(interfaces)) {
-        const iface = interfaces[name];
-
-        if (!iface) {
-            continue;
-        }
-
-        for (const net of iface) {
-            if (net.internal || net.family !== 'IPv4') {
-                continue;
-            }
-
-            if (net.mac && net.mac !== '00:00:00:00:00:00') {
-                return net.mac.toUpperCase();
-            }
-        }
-    }
-
-    return null;
-}

package/src/net/index.ts

@@ -1,2 +0,0 @@
-export { default as getLocalIP } from './getLocalIP';
-export { default as getMacAddress } from './getMacAddress';