homebridge-lovesac-stealthtech 0.0.0-development

package/dist/ble/BleClient.d.ts

@@ -0,0 +1,28 @@
+import type { Logger } from 'homebridge';
+export type NotificationHandler = (data: Buffer) => void;
+export interface IBleClient {
+    connect(address?: string): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    resolvedAddress: string;
+    write(characteristicUuid: string, data: Buffer): Promise<void>;
+    subscribeNotifications(handler: NotificationHandler): Promise<void>;
+}
+export declare class BleClient implements IBleClient {
+    private readonly log;
+    private peripheral;
+    private characteristics;
+    private notificationHandler;
+    private _connected;
+    private _resolvedAddress;
+    constructor(log: Logger);
+    get resolvedAddress(): string;
+    connect(address?: string): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    write(characteristicUuid: string, data: Buffer): Promise<void>;
+    subscribeNotifications(handler: NotificationHandler): Promise<void>;
+    private scanForAnyDevice;
+    private scanForDevice;
+    private scan;
+}

package/dist/ble/BleClient.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleClient = void 0;
+const noble_1 = __importDefault(require("@stoprocent/noble"));
+const settings_1 = require("../settings");
+class BleClient {
+    log;
+    peripheral = null;
+    characteristics = {};
+    notificationHandler = null;
+    _connected = false;
+    _resolvedAddress = '';
+    constructor(log) {
+        this.log = log;
+    }
+    get resolvedAddress() {
+        return this._resolvedAddress;
+    }
+    async connect(address) {
+        if (this._connected) {
+            return;
+        }
+        let peripheral;
+        if (address) {
+            this.log.debug('BLE: Starting scan for %s...', address);
+            peripheral = await this.scanForDevice(address);
+            if (!peripheral) {
+                throw new Error(`Device ${address} not found`);
+            }
+        }
+        else {
+            this.log.debug('BLE: Starting auto-discovery scan...');
+            peripheral = await this.scanForAnyDevice();
+            if (!peripheral) {
+                throw new Error('No Lovesac StealthTech device found');
+            }
+        }
+        const resolvedId = peripheral.address !== '' && peripheral.address !== 'unknown'
+            ? peripheral.address
+            : peripheral.id ?? peripheral.uuid ?? 'unknown';
+        this.log.debug('BLE: Connecting to %s...', resolvedId);
+        this._resolvedAddress = resolvedId;
+        // Register disconnect handler BEFORE connecting to avoid race (P0-2)
+        peripheral.once('disconnect', () => {
+            this.log.debug('BLE: Disconnected');
+            this._connected = false;
+            this.peripheral = null;
+            this.characteristics = {};
+        });
+        await peripheral.connectAsync();
+        this._connected = true;
+        this.peripheral = peripheral;
+        this.log.debug('BLE: Discovering services and characteristics...');
+        const { characteristics } = await peripheral.discoverSomeServicesAndCharacteristicsAsync([settings_1.SOFA_SERVICE_UUID_SHORT], Object.values(settings_1.CharUUID));
+        for (const char of characteristics) {
+            this.characteristics[char.uuid] = char;
+        }
+        this.log.debug('BLE: Found %d characteristics', Object.keys(this.characteristics).length);
+    }
+    async disconnect() {
+        if (this.peripheral && this._connected) {
+            try {
+                await this.peripheral.disconnectAsync();
+            }
+            catch {
+                // Already disconnected
+            }
+        }
+        this._connected = false;
+        this.peripheral = null;
+        this.characteristics = {};
+    }
+    isConnected() {
+        return this._connected;
+    }
+    async write(characteristicUuid, data) {
+        const char = this.characteristics[characteristicUuid];
+        if (!char) {
+            throw new Error(`Characteristic ${characteristicUuid} not found. Available: ${Object.keys(this.characteristics).join(', ')}`);
+        }
+        // Write without response (as per protocol spec)
+        await char.writeAsync(data, true);
+    }
+    async subscribeNotifications(handler) {
+        this.notificationHandler = handler;
+        const upstream = this.characteristics[settings_1.CharUUID.UpStream];
+        if (!upstream) {
+            throw new Error('UpStream characteristic not found');
+        }
+        // Remove previous listeners to prevent leak on reconnect (P0-1)
+        upstream.removeAllListeners('data');
+        upstream.on('data', (data) => {
+            if (this.notificationHandler) {
+                try {
+                    this.notificationHandler(data);
+                }
+                catch (err) {
+                    this.log.error('BLE: Notification handler error: %s', err);
+                }
+            }
+        });
+        await upstream.subscribeAsync();
+        this.log.debug('BLE: Subscribed to UpStream notifications');
+    }
+    scanForAnyDevice() {
+        return this.scan((_peripheral) => {
+            return true; // accept the first device with the right service UUID
+        });
+    }
+    scanForDevice(address) {
+        const normalized = address.toLowerCase().replace(/[:-]/g, '');
+        return this.scan((peripheral) => {
+            const id = peripheral.id?.toLowerCase().replace(/[:-]/g, '') ?? '';
+            const addr = peripheral.address?.toLowerCase().replace(/[:-]/g, '') ?? '';
+            const uuid = peripheral.uuid?.toLowerCase().replace(/[:-]/g, '') ?? '';
+            return id === normalized || addr === normalized || uuid === normalized;
+        });
+    }
+    scan(match) {
+        return new Promise((resolve, reject) => {
+            const onDiscover = (peripheral) => {
+                if (!match(peripheral)) {
+                    return;
+                }
+                clearTimeout(timeout);
+                cleanup();
+                const name = peripheral.advertisement?.localName ?? '(unnamed)';
+                this.log.info('BLE: Discovered device: %s', name);
+                resolve(peripheral);
+            };
+            const cleanup = () => {
+                noble_1.default.stopScanning();
+                noble_1.default.removeListener('discover', onDiscover);
+            };
+            const timeout = setTimeout(() => {
+                cleanup();
+                resolve(null);
+            }, settings_1.BLE_SCAN_TIMEOUT);
+            noble_1.default.on('discover', onDiscover);
+            const startScan = () => {
+                noble_1.default.startScanning([settings_1.SOFA_SERVICE_UUID_SHORT], false, (err) => {
+                    if (err) {
+                        clearTimeout(timeout);
+                        cleanup();
+                        reject(err);
+                    }
+                });
+            };
+            if (noble_1.default.state === 'poweredOn') {
+                startScan();
+            }
+            else {
+                noble_1.default.once('stateChange', (state) => {
+                    if (state === 'poweredOn') {
+                        startScan();
+                    }
+                    else {
+                        clearTimeout(timeout);
+                        cleanup();
+                        reject(new Error(`Bluetooth adapter state: ${state}`));
+                    }
+                });
+            }
+        });
+    }
+}
+exports.BleClient = BleClient;

package/dist/ble/BleConnectionManager.d.ts

@@ -0,0 +1,29 @@
+import type { Logger } from 'homebridge';
+import type { IBleClient, NotificationHandler } from './BleClient';
+import type { BleCommand } from '../protocol/commands';
+export declare class BleConnectionManager {
+    private readonly client;
+    private readonly address;
+    private readonly idleTimeout;
+    private readonly log;
+    private queue;
+    private processing;
+    private idleTimer;
+    private connected;
+    private notificationHandler;
+    private connectPromise;
+    private resolvedAddress;
+    private onReconnectCallback;
+    constructor(client: IBleClient, address: string, idleTimeout: number, log: Logger);
+    getResolvedAddress(): string;
+    setNotificationHandler(handler: NotificationHandler): void;
+    onReconnect(callback: () => void): void;
+    enqueue(command: BleCommand): Promise<void>;
+    ensureConnected(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    private doConnect;
+    private processQueue;
+    private resetIdleTimer;
+    private clearIdleTimer;
+}

package/dist/ble/BleConnectionManager.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleConnectionManager = void 0;
+const settings_1 = require("../settings");
+class BleConnectionManager {
+    client;
+    address;
+    idleTimeout;
+    log;
+    queue = [];
+    processing = false;
+    idleTimer = null;
+    connected = false;
+    notificationHandler = null;
+    connectPromise = null;
+    resolvedAddress;
+    onReconnectCallback = null;
+    constructor(client, address, idleTimeout, log) {
+        this.client = client;
+        this.address = address;
+        this.idleTimeout = idleTimeout;
+        this.log = log;
+        this.resolvedAddress = address;
+    }
+    getResolvedAddress() {
+        return this.resolvedAddress;
+    }
+    setNotificationHandler(handler) {
+        this.notificationHandler = handler;
+    }
+    onReconnect(callback) {
+        this.onReconnectCallback = callback;
+    }
+    async enqueue(command) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({ command, resolve, reject });
+            this.processQueue();
+        });
+    }
+    async ensureConnected() {
+        if (this.connected && this.client.isConnected()) {
+            this.resetIdleTimer();
+            return;
+        }
+        // Reuse in-flight connection attempt
+        if (this.connectPromise) {
+            await this.connectPromise;
+            return;
+        }
+        this.connectPromise = this.doConnect();
+        try {
+            await this.connectPromise;
+        }
+        finally {
+            this.connectPromise = null;
+        }
+    }
+    async disconnect() {
+        this.clearIdleTimer();
+        this.connected = false;
+        await this.client.disconnect();
+    }
+    isConnected() {
+        return this.connected && this.client.isConnected();
+    }
+    async doConnect() {
+        const label = this.resolvedAddress || 'auto-discovery';
+        this.log.info('Connecting to %s...', label);
+        try {
+            await this.client.connect(this.address || undefined);
+            // After first connect, lock to the resolved address for reconnects
+            if (!this.address && this.client.resolvedAddress) {
+                this.resolvedAddress = this.client.resolvedAddress;
+                this.log.info('Auto-discovered device: %s', this.resolvedAddress);
+            }
+            await this.client.subscribeNotifications((data) => {
+                this.resetIdleTimer();
+                if (this.notificationHandler) {
+                    this.notificationHandler(data);
+                }
+            });
+            this.connected = true;
+            this.resetIdleTimer();
+            this.log.info('Connected to %s', this.resolvedAddress);
+            if (this.onReconnectCallback) {
+                this.onReconnectCallback();
+            }
+        }
+        catch (err) {
+            this.connected = false;
+            throw err;
+        }
+    }
+    async processQueue() {
+        if (this.processing) {
+            return;
+        }
+        this.processing = true;
+        try {
+            while (this.queue.length > 0) {
+                const item = this.queue.shift();
+                try {
+                    await this.ensureConnected();
+                    await this.client.write(item.command.characteristicUuid, item.command.data);
+                    this.resetIdleTimer();
+                    item.resolve();
+                }
+                catch (err) {
+                    // On write failure, disconnect and retry once
+                    this.log.warn('BLE write failed, reconnecting: %s', (0, settings_1.errorMessage)(err));
+                    this.connected = false;
+                    try {
+                        await this.client.disconnect();
+                    }
+                    catch {
+                        // Ignore disconnect errors
+                    }
+                    try {
+                        await this.ensureConnected();
+                        await this.client.write(item.command.characteristicUuid, item.command.data);
+                        this.resetIdleTimer();
+                        item.resolve();
+                    }
+                    catch (retryErr) {
+                        item.reject(retryErr);
+                    }
+                }
+            }
+        }
+        finally {
+            this.processing = false;
+        }
+    }
+    resetIdleTimer() {
+        this.clearIdleTimer();
+        this.idleTimer = setTimeout(() => {
+            this.log.info('Idle timeout, disconnecting from %s', this.resolvedAddress);
+            this.disconnect().catch((err) => {
+                this.log.warn('Error during idle disconnect: %s', (0, settings_1.errorMessage)(err));
+            });
+        }, this.idleTimeout * 1000);
+    }
+    clearIdleTimer() {
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = null;
+        }
+    }
+}
+exports.BleConnectionManager = BleConnectionManager;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { API } from 'homebridge';
+declare const _default: (api: API) => void;
+export default _default;

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const settings_1 = require("./settings");
+const platform_1 = require("./platform");
+exports.default = (api) => {
+    api.registerPlatform(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, platform_1.LovesacPlatform);
+};

package/dist/platform.d.ts

@@ -0,0 +1,13 @@
+import type { API, DynamicPlatformPlugin, Logger, PlatformAccessory } from 'homebridge';
+import type { LovesacPlatformConfig } from './settings';
+export declare class LovesacPlatform implements DynamicPlatformPlugin {
+    readonly log: Logger;
+    readonly config: LovesacPlatformConfig;
+    readonly api: API;
+    private readonly accessories;
+    private device;
+    private connectionManager;
+    constructor(log: Logger, config: LovesacPlatformConfig, api: API);
+    configureAccessory(_accessory: PlatformAccessory): void;
+    private discoverDevices;
+}

package/dist/platform.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LovesacPlatform = void 0;
+const settings_1 = require("./settings");
+const accessory_1 = require("./accessory");
+const BleClient_1 = require("./ble/BleClient");
+const BleConnectionManager_1 = require("./ble/BleConnectionManager");
+const LovesacDevice_1 = require("./protocol/LovesacDevice");
+class LovesacPlatform {
+    log;
+    config;
+    api;
+    accessories = [];
+    device = null;
+    connectionManager = null;
+    constructor(log, config, api) {
+        this.log = log;
+        this.config = config;
+        this.api = api;
+        this.log.info('Lovesac StealthTech platform initialized');
+        this.api.on('didFinishLaunching', () => {
+            this.discoverDevices();
+        });
+        this.api.on('shutdown', () => {
+            this.device?.stopPolling();
+            this.connectionManager?.disconnect().catch(() => { });
+        });
+    }
+    // Required by DynamicPlatformPlugin — we don't use cached accessories for external accessories
+    configureAccessory(_accessory) {
+        // External accessories are not cached, so this is a no-op
+    }
+    discoverDevices() {
+        let devices = this.config.devices ?? [];
+        // If no devices configured at all, create a default entry for auto-discovery
+        if (devices.length === 0) {
+            this.log.info('No devices configured — will auto-discover via BLE.');
+            devices = [{}];
+        }
+        if (devices.length > 1) {
+            this.log.warn('Multiple devices configured — only the first device is supported in this version.');
+        }
+        const rawConfig = devices[0];
+        const deviceConfig = (0, settings_1.resolveDeviceConfig)(rawConfig);
+        if (deviceConfig.address) {
+            this.log.info('Setting up device: %s (%s)', deviceConfig.name, deviceConfig.address);
+        }
+        else {
+            this.log.info('Setting up device: %s (auto-discovery)', deviceConfig.name);
+        }
+        // Generate a stable UUID from the BLE address + plugin name
+        // _testSuffix in config allows generating a fresh identity for testing
+        // For auto-discovery, use a fixed seed so the identity is stable
+        const addressSeed = deviceConfig.address || 'auto';
+        const uuidSeed = 'lovesac-st:' + addressSeed + (rawConfig._testSuffix ?? '');
+        const uuid = this.api.hap.uuid.generate(uuidSeed);
+        const accessory = new this.api.platformAccessory(deviceConfig.name, uuid);
+        // Create BLE stack
+        const bleClient = new BleClient_1.BleClient(this.log);
+        this.connectionManager = new BleConnectionManager_1.BleConnectionManager(bleClient, deviceConfig.address, deviceConfig.idleTimeout, this.log);
+        this.device = new LovesacDevice_1.LovesacDevice(this.connectionManager, this.log);
+        const device = this.device;
+        // Create accessory handler
+        const handler = new accessory_1.LovesacAccessory(this, accessory, deviceConfig, device);
+        this.accessories.push(handler);
+        // Audio receiver icon — closer to a soundbar than the TV icon
+        accessory.category = 34 /* this.api.hap.Categories.AUDIO_RECEIVER */;
+        this.api.publishExternalAccessories(settings_1.PLUGIN_NAME, [accessory]);
+    }
+}
+exports.LovesacPlatform = LovesacPlatform;

package/dist/protocol/LovesacDevice.d.ts

@@ -0,0 +1,35 @@
+import type { Logger } from 'homebridge';
+import { BleConnectionManager } from '../ble/BleConnectionManager';
+import { DeviceState } from './responses';
+import { ResponseCode, PresetWriteValue, PresetReadValue, SourceValue } from './constants';
+export type StateChangeListener = (code: ResponseCode, value: number) => void;
+export declare class LovesacDevice {
+    private readonly connectionManager;
+    private readonly log;
+    readonly state: DeviceState;
+    private stateListeners;
+    private stateInitialized;
+    mcuVersion: string;
+    private versionListeners;
+    private pollTimer;
+    constructor(connectionManager: BleConnectionManager, log: Logger);
+    onStateChange(listener: StateChangeListener): void;
+    isStateInitialized(): boolean;
+    onVersionResolved(callback: () => void): void;
+    requestStateRefresh(): Promise<void>;
+    startPolling(intervalSeconds: number): void;
+    stopPolling(): void;
+    getResolvedAddress(): string;
+    setPower(on: boolean): Promise<void>;
+    setVolume(volume: number): Promise<void>;
+    volumeToPercent(volume: number): number;
+    percentToVolume(percent: number): number;
+    volumeUp(step: number): Promise<void>;
+    volumeDown(step: number): Promise<void>;
+    setMute(muted: boolean): Promise<void>;
+    setQuietMode(on: boolean): Promise<void>;
+    setSource(source: SourceValue): Promise<void>;
+    setPreset(preset: PresetWriteValue): Promise<void>;
+    isPresetActive(readValue: PresetReadValue): boolean;
+    private handleNotification;
+}