@basmilius/apple-companion-link 0.0.1

package/src/encoding/tlv8.ts

@@ -0,0 +1,111 @@
+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

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

package/src/net/getLocalIP.ts

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,25 @@
+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

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

package/src/protocol/api/companionLink.ts

@@ -0,0 +1,353 @@
+import { randomInt } from 'node:crypto';
+import { debug, waitFor } from '@/cli';
+import { opackFloat, parseBinaryPlist } from '@/encoding';
+import { CompanionLinkFrameType, CompanionLinkMessageType, type CompanionLinkSocket } from '@/socket';
+import type CompanionLink from '../companionLink';
+
+export default class Api {
+    readonly #protocol: CompanionLink;
+    readonly #socket: CompanionLinkSocket;
+
+    constructor(protocol: CompanionLink, socket: CompanionLinkSocket) {
+        this.#protocol = protocol;
+        this.#socket = socket;
+    }
+
+    async fetchMediaControlStatus(): Promise<void> {
+        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
+            _i: 'FetchMediaControlStatus',
+            _t: CompanionLinkMessageType.Request,
+            _c: {}
+        });
+    }
+
+    async fetchNowPlayingInfo(): Promise<void> {
+        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
+            _i: 'FetchCurrentNowPlayingInfoEvent',
+            _t: CompanionLinkMessageType.Request,
+            _c: {}
+        });
+    }
+
+    async fetchSupportedActions(): Promise<void> {
+        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
+            _i: 'FetchSupportedActionsEvent',
+            _t: CompanionLinkMessageType.Request,
+            _c: {}
+        });
+    }
+
+    async getAttentionState(): Promise<AttentionState> {
+        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
+            _i: 'FetchAttentionState',
+            _t: CompanionLinkMessageType.Request,
+            _c: {}
+        });
+
+        const {_c} = objectOrFail<AttentionStateResponse>(payload);
+
+        switch (_c.state) {
+            case 0x01:
+                return 'asleep';
+
+            case 0x02:
+                return 'screensaver';
+
+            case 0x03:
+                return 'awake';
+
+            case 0x04:
+                return 'idle';
+
+            default:
+                return 'unknown';
+        }
+    }
+
+    async getLaunchableApps(): Promise<LaunchableApp[]> {
+        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
+            _i: 'FetchLaunchableApplicationssEvent',
+            _t: CompanionLinkMessageType.Request,
+            _c: {}
+        });
+
+        const {_c} = objectOrFail<LaunchableAppsResponse>(payload);
+
+        return Object.entries(_c).map(([bundleId, name]) => ({
+            bundleId,
+            name
+        }));
+    }
+
+    async getSiriRemoteInfo(): Promise<any> {
+        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
+            _i: 'FetchSiriRemoteInfo',
+            _t: CompanionLinkMessageType.Request,
+            _c: {}
+        });
+
+        return parseBinaryPlist(Buffer.from(payload['_c']['SiriRemoteInfoKey']).buffer);
+    }
+
+    async getUserAccounts(): Promise<UserAccount[]> {
+        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
+            _i: 'FetchUserAccountsEvent',
+            _t: CompanionLinkMessageType.Request,
+            _c: {}
+        });
+
+        const {_c} = objectOrFail<UserAccountsResponse>(payload);
+
+        return Object.entries(_c).map(([accountId, name]) => ({
+            accountId,
+            name
+        }));
+    }
+
+    async hidCommand(command: keyof typeof HidCommand, down = false): Promise<void> {
+        await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
+            _i: '_hidC',
+            _t: CompanionLinkMessageType.Request,
+            _c: {
+                _hBtS: down ? 1 : 2,
+                _hidC: HidCommand[command]
+            }
+        });
+    }
+
+    async launchApp(bundleId: string): Promise<void> {
+        await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
+            _i: '_launchApp',
+            _t: CompanionLinkMessageType.Request,
+            _c: {
+                _bundleID: bundleId
+            }
+        });
+    }
+
+    async launchUrl(url: string): Promise<void> {
+        await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
+            _i: '_launchApp',
+            _t: CompanionLinkMessageType.Request,
+            _c: {
+                _urlS: url
+            }
+        });
+    }
+
+    async mediaControlCommand(command: keyof typeof MediaControlCommand, content?: object): Promise<object> {
+        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
+            _i: '_mcc',
+            _t: CompanionLinkMessageType.Request,
+            _c: {
+                _mcc: MediaControlCommand[command],
+                ...(content || {})
+            }
+        });
+
+        return objectOrFail(payload);
+    }
+
+    async pressButton(command: keyof typeof HidCommand, type: ButtonPressType = 'SingleTap', holdDelayMs = 500): Promise<void> {
+        switch (type) {
+            case 'DoubleTap':
+                await this.hidCommand(command, true);
+                await this.hidCommand(command, false);
+
+                await this.hidCommand(command, true);
+                await this.hidCommand(command, false);
+                break;
+
+            case 'Hold':
+                await this.hidCommand(command, true);
+                await waitFor(holdDelayMs);
+                await this.hidCommand(command, false);
+                break;
+
+            case 'SingleTap':
+                await this.hidCommand(command, true);
+                await this.hidCommand(command, false);
+                break;
+        }
+    }
+
+    async switchUserAccount(accountId: string): Promise<void> {
+        await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
+            _i: 'SwitchUserAccountEvent',
+            _t: CompanionLinkMessageType.Request,
+            _c: {
+                SwitchAccountID: accountId
+            }
+        });
+    }
+
+    async _subscribe(event: string, fn: EventListener): Promise<void> {
+        this.#socket.addEventListener(event, fn);
+
+        await this.#socket.send(CompanionLinkFrameType.E_OPACK, {
+            _i: '_interest',
+            _t: CompanionLinkMessageType.Event,
+            _c: {
+                _regEvents: [event]
+            }
+        });
+    }
+
+    async _unsubscribe(event: string, fn?: EventListener): Promise<void> {
+        if (fn) {
+            this.#socket.removeEventListener(event, fn);
+        }
+
+        await this.#socket.send(CompanionLinkFrameType.E_OPACK, {
+            _i: '_interest',
+            _t: CompanionLinkMessageType.Event,
+            _c: {
+                _deregEvents: [event]
+            }
+        });
+    }
+
+    async _sessionStart(): Promise<object> {
+        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
+            _i: '_sessionStart',
+            _t: CompanionLinkMessageType.Request,
+            _c: {
+                _srvT: 'com.apple.tvremoteservices',
+                _sid: randomInt(0, 2 ** 32 - 1)
+            }
+        });
+
+        return objectOrFail(payload);
+    }
+
+    async _systemInfo(pairingId: Buffer): Promise<object> {
+        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
+            _i: '_systemInfo',
+            _t: CompanionLinkMessageType.Request,
+            _c: {
+                _bf: 0,
+                _cf: 512,
+                _clFl: 128,
+                _i: 'cafecafecafe',
+                _idsID: pairingId.toString(),
+                _pubID: 'FF:70:79:61:74:76',
+                _sf: 256,
+                _sv: '170.18',
+                model: 'iPhone10,6',
+                name: 'Bas Companion Link'
+            }
+        });
+
+        return objectOrFail(payload);
+    }
+
+    async _touchStart(): Promise<object> {
+        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
+            _i: '_touchStart',
+            _t: CompanionLinkMessageType.Request,
+            _c: {
+                _height: opackFloat(1000.0),
+                _tFl: 0,
+                _width: opackFloat(1000.0)
+            }
+        });
+
+        return objectOrFail(payload);
+    }
+
+    async _tvrcSessionStart(): Promise<object> {
+        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
+            _i: 'TVRCSessionStart',
+            _t: CompanionLinkMessageType.Request,
+            _btHP: false,
+            _inUseProc: 'tvremoted',
+            _c: {}
+        });
+
+        return objectOrFail(payload);
+    }
+}
+
+const HidCommand = {
+    Up: 1,
+    Down: 2,
+    Left: 3,
+    Right: 4,
+    Menu: 5,
+    Select: 6,
+    Home: 7,
+    VolumeUp: 8,
+    VolumeDown: 9,
+    Siri: 10,
+    Screensaver: 11,
+    Sleep: 12,
+    Wake: 13,
+    PlayPause: 14,
+    ChannelIncrement: 15,
+    ChannelDecrement: 16,
+    Guide: 17,
+    PageUp: 18,
+    PageDown: 19
+} as const;
+
+const MediaControlCommand = {
+    Play: 1,
+    Pause: 2,
+    NextTrack: 3,
+    PreviousTrack: 4,
+    GetVolume: 5,
+    SetVolume: 6,
+    SkipBy: 7,
+    FastForwardBegin: 8,
+    FastForwardEnd: 9,
+    RewindBegin: 10,
+    RewindEnd: 11,
+    GetCaptionSettings: 12,
+    SetCaptionSettings: 13
+} as const;
+
+type ButtonPressType =
+    | 'DoubleTap'
+    | 'Hold'
+    | 'SingleTap';
+
+function objectOrFail<T = object>(obj: unknown): T {
+    if (typeof obj === 'object') {
+        return obj as T;
+    }
+
+    debug('Expected an object.', {obj});
+
+    throw new Error('Expected an object.');
+}
+
+type AttentionState =
+    | 'unknown'
+    | 'asleep'
+    | 'screensaver'
+    | 'awake'
+    | 'idle';
+
+type AttentionStateResponse = {
+    readonly _c: {
+        readonly state: number;
+    };
+};
+
+type LaunchableApp = {
+    readonly bundleId: string;
+    readonly name: string;
+};
+
+type LaunchableAppsResponse = {
+    readonly _c: Record<string, string>;
+};
+
+type UserAccount = {
+    readonly accountId: string;
+    readonly name: string;
+};
+
+type UserAccountsResponse = {
+    readonly _c: Record<string, string>;
+};

package/src/protocol/companionLink.ts

@@ -0,0 +1,41 @@
+import { Result } from 'node-dns-sd';
+import { CompanionLinkSocket } from '@/socket';
+import Api from './api/companionLink';
+import Pairing from './pairing/companionLink';
+import Verify from './verify/companionLink';
+
+export default class CompanionLink {
+    get api(): Api {
+        return this.#api;
+    }
+
+    get socket(): CompanionLinkSocket {
+        return this.#socket;
+    }
+
+    get pairing(): Pairing {
+        return this.#pairing;
+    }
+
+    get verify(): Verify {
+        return this.#verify;
+    }
+
+    readonly #api: Api;
+    readonly #device: Result;
+    readonly #socket: CompanionLinkSocket;
+    readonly #pairing: Pairing;
+    readonly #verify: Verify;
+
+    constructor(device: Result) {
+        this.#device = device;
+        this.#socket = new CompanionLinkSocket(device.address, device.service.port);
+        this.#api = new Api(this, this.#socket);
+        this.#pairing = new Pairing(this, this.#socket);
+        this.#verify = new Verify(this, this.#socket);
+    }
+
+    async connect(): Promise<void> {
+        await this.#socket.connect();
+    }
+}

package/src/protocol/index.ts

@@ -0,0 +1 @@
+export { default as CompanionLink } from './companionLink';