ember-mug 0.3.1 → 0.3.2

package/dist/cli.js

@@ -1,8 +1,24 @@
 #!/usr/bin/env node
-import { jsx as _jsx } from "react/jsx-runtime";
-import { render } from "ink";
-import { App } from "./components/App.js";
-import { isMockMode, setBluetoothManager } from "./lib/bluetooth.js";
+// Parse command line arguments BEFORE importing modules that initialize Bluetooth
+const args = process.argv.slice(2);
+const showHelp = args.includes('--help') || args.includes('-h');
+const debugMode = args.includes('--debug') || args.includes('-d');
+if (showHelp) {
+    console.log(`
+ember-mug - CLI for controlling Ember mugs via Bluetooth
+
+Usage:
+  ember-mug [options]
+
+Options:
+  -d, --debug    Enable debug mode (outputs detailed Bluetooth logs)
+  -h, --help     Show this help message
+
+Environment variables:
+  EMBER_MOCK=true    Run in mock mode (simulates mug for testing)
+`);
+    process.exit(0);
+}
 // ANSI escape codes for alternate screen buffer
 const enterAltScreen = "\x1b[?1049h";
 const exitAltScreen = "\x1b[?1049l";
@@ -26,13 +42,24 @@ process.stdout.on("resize", () => {
     process.stdout.write(clearScreen);
 });
 async function main() {
+    // Dynamic imports to avoid initializing Bluetooth for --help
+    const { setDebugMode } = await import("./lib/debug.js");
+    // Enable debug mode if flag is set
+    if (debugMode) {
+        setDebugMode(true);
+    }
+    const React = await import("react");
+    const { render } = await import("ink");
+    const { App } = await import("./components/App.js");
+    const { isMockMode, setBluetoothManager } = await import("./lib/bluetooth.js");
     // Initialize mock manager if in mock mode (set via EMBER_MOCK env var)
     if (isMockMode()) {
         const { getMockBluetoothManager } = await import("./lib/mock-bluetooth.js");
+        const { BluetoothManager } = await import("./lib/bluetooth.js");
         setBluetoothManager(getMockBluetoothManager());
     }
     // Render the app
-    const app = render(_jsx(App, {}));
+    const app = render(React.createElement(App));
     await app.waitUntilExit();
     process.exit(0);
 }
@@ -41,3 +68,4 @@ main().catch((error) => {
     console.error("Failed to start:", error);
     process.exit(1);
 });
+export {};

package/dist/lib/bluetooth.js

@@ -1,6 +1,7 @@
 import noble from '@abandonware/noble';
 import { EventEmitter } from 'events';
 import { LiquidState, TemperatureUnit, EMBER_SERVICE_UUID, EMBER_CHARACTERISTICS, MIN_TEMP_CELSIUS, MAX_TEMP_CELSIUS, } from './types.js';
+import { debug } from './debug.js';
 // Noble's state property exists but isn't properly typed
 const getNobleState = () => noble.state;
 export class BluetoothManager extends EventEmitter {
@@ -24,67 +25,91 @@ export class BluetoothManager extends EventEmitter {
         this.setupNobleListeners();
     }
     setupNobleListeners() {
+        debug('Setting up Noble Bluetooth listeners');
         noble.on('stateChange', (state) => {
+            debug('Bluetooth adapter state changed:', state);
             if (state === 'poweredOn') {
-                // Ready for scanning
+                debug('Bluetooth adapter is powered on and ready');
             }
             else {
+                debug('Bluetooth adapter not ready, state:', state);
                 this.emit('error', new Error(`Bluetooth state: ${state}`));
             }
         });
         noble.on('discover', async (peripheral) => {
             const name = peripheral.advertisement.localName || '';
+            const uuid = peripheral.uuid || 'unknown';
+            const rssi = peripheral.rssi || 'unknown';
+            debug(`Discovered device: name="${name}", uuid=${uuid}, rssi=${rssi}`);
             if (name.toLowerCase().includes('ember')) {
+                debug(`Found Ember mug: "${name}"`);
                 this.emit('mugFound', name);
                 await this.stopScanning();
                 this.peripheral = peripheral;
+                debug('Starting connection process...');
                 await this.connectWithRetry();
             }
         });
     }
     async connectWithRetry(maxRetries = 3) {
         let lastError = null;
+        debug(`Starting connection with up to ${maxRetries} retries`);
         for (let attempt = 1; attempt <= maxRetries; attempt++) {
             try {
+                debug(`Connection attempt ${attempt}/${maxRetries}`);
                 await this.connect();
+                debug('Connection successful!');
                 return; // Success
             }
             catch (err) {
                 lastError = err instanceof Error ? err : new Error(String(err));
+                debug(`Connection attempt ${attempt} failed:`, lastError.message);
                 if (attempt < maxRetries) {
                     // Wait before retrying (exponential backoff: 1s, 2s, 4s)
                     const delay = Math.pow(2, attempt - 1) * 1000;
+                    debug(`Waiting ${delay}ms before retry...`);
                     await new Promise(resolve => setTimeout(resolve, delay));
                 }
             }
         }
         // All retries failed
+        debug('All connection attempts failed');
         this.emit('error', lastError || new Error('Connection failed after multiple attempts'));
     }
     async startScanning() {
+        debug('startScanning() called');
+        const currentState = getNobleState();
+        debug('Current Bluetooth adapter state:', currentState);
         return new Promise((resolve, reject) => {
             // Scan without service UUID filter - Ember mugs don't always advertise
             // the service UUID in their advertisement packets. We filter by name instead.
             const startScan = () => {
+                debug('Starting BLE scan (no service UUID filter, filtering by name)');
                 this.emit('scanning', true);
                 noble.startScanning([], false, (error) => {
                     if (error) {
+                        debug('Failed to start scanning:', error.message);
                         reject(error);
                     }
                     else {
+                        debug('BLE scan started successfully');
                         resolve();
                     }
                 });
             };
-            if (getNobleState() === 'poweredOn') {
+            if (currentState === 'poweredOn') {
+                debug('Bluetooth adapter ready, starting scan immediately');
                 startScan();
             }
             else {
+                debug('Bluetooth adapter not ready, waiting for state change...');
                 noble.once('stateChange', (state) => {
+                    debug('Bluetooth state changed to:', state);
                     if (state === 'poweredOn') {
                         startScan();
                     }
                     else {
+                        debug('Bluetooth not available, cannot scan');
                         reject(new Error(`Bluetooth not available: ${state}`));
                     }
                 });
@@ -92,16 +117,25 @@ export class BluetoothManager extends EventEmitter {
         });
     }
     async stopScanning() {
+        debug('Stopping BLE scan');
         this.emit('scanning', false);
         return new Promise((resolve) => {
-            noble.stopScanning(() => resolve());
+            noble.stopScanning(() => {
+                debug('BLE scan stopped');
+                resolve();
+            });
         });
     }
     async connect() {
         if (!this.peripheral) {
+            debug('connect() called but no peripheral available');
             throw new Error('No peripheral to connect to');
         }
         const CONNECTION_TIMEOUT = 10000; // 10 seconds timeout
+        const peripheralUuid = this.peripheral.uuid || 'unknown';
+        const peripheralName = this.peripheral.advertisement.localName || 'unknown';
+        debug(`Connecting to peripheral: name="${peripheralName}", uuid=${peripheralUuid}`);
+        debug(`Connection timeout set to ${CONNECTION_TIMEOUT}ms`);
         return new Promise((resolve, reject) => {
             let timeoutId = null;
             let connected = false;
@@ -113,41 +147,56 @@ export class BluetoothManager extends EventEmitter {
             };
             timeoutId = setTimeout(() => {
                 if (!connected) {
+                    debug(`Connection timeout reached after ${CONNECTION_TIMEOUT}ms`);
                     cleanup();
                     // Try to cancel the connection attempt
                     try {
+                        debug('Attempting to disconnect peripheral after timeout');
                         this.peripheral?.disconnect();
                     }
-                    catch {
+                    catch (e) {
+                        debug('Error during post-timeout disconnect:', e);
                         // Ignore disconnect errors during timeout
                     }
                     reject(new Error('Connection timed out. Make sure your mug is nearby and awake.'));
                 }
             }, CONNECTION_TIMEOUT);
+            debug('Calling peripheral.connect()...');
             this.peripheral.connect(async (error) => {
                 if (error) {
+                    debug('peripheral.connect() callback received error:', error);
                     cleanup();
                     reject(new Error(`Failed to connect: ${error}`));
                     return;
                 }
+                debug('peripheral.connect() callback: connection established');
                 connected = true;
                 cleanup();
                 this.isConnected = true;
                 this.state.connected = true;
                 this.state.mugName = this.peripheral.advertisement.localName || 'Ember Mug';
+                debug(`Connected to mug: "${this.state.mugName}"`);
                 this.peripheral.once('disconnect', () => {
+                    debug('Peripheral disconnect event received');
                     this.handleDisconnect();
                 });
                 try {
+                    debug('Starting service/characteristic discovery...');
                     await this.discoverCharacteristics();
+                    debug('Setting up push notifications...');
                     await this.setupNotifications();
+                    debug('Reading initial values from mug...');
                     await this.readInitialValues();
+                    debug('Starting polling loop...');
                     this.startPolling();
+                    debug('Connection setup complete');
                     this.emit('connected');
                     this.emitState();
                     resolve();
                 }
                 catch (err) {
+                    const errorMsg = err instanceof Error ? err.message : String(err);
+                    debug('Error during post-connection setup:', errorMsg);
                     this.handleDisconnect();
                     reject(err instanceof Error ? err : new Error(String(err)));
                 }
@@ -155,44 +204,56 @@ export class BluetoothManager extends EventEmitter {
         });
     }
     async discoverCharacteristics() {
+        debug(`Discovering Ember service (UUID: ${EMBER_SERVICE_UUID})...`);
         // First discover the Ember service specifically
         const services = await new Promise((resolve, reject) => {
             this.peripheral.discoverServices([EMBER_SERVICE_UUID], (error, services) => {
                 if (error) {
+                    debug('Error discovering services:', error);
                     reject(error);
                     return;
                 }
+                debug(`Found ${services?.length || 0} services`);
                 resolve(services || []);
             });
         });
         if (services.length === 0) {
+            debug('Ember service not found on device!');
             throw new Error('Ember service not found on device');
         }
         // Then discover characteristics for that service
         const emberService = services[0];
+        debug(`Discovering characteristics for Ember service...`);
         return new Promise((resolve, reject) => {
             emberService.discoverCharacteristics([], (error, characteristics) => {
                 if (error) {
+                    debug('Error discovering characteristics:', error);
                     reject(error);
                     return;
                 }
+                debug(`Found ${characteristics?.length || 0} characteristics`);
                 for (const char of characteristics || []) {
                     const uuid = char.uuid.toLowerCase().replace(/-/g, '');
+                    debug(`  - Characteristic: ${uuid}`);
                     this.characteristics.set(uuid, char);
                 }
+                debug('Characteristic discovery complete');
                 resolve();
             });
         });
     }
     async setupNotifications() {
+        debug('Setting up push event notifications...');
         const pushEventsChar = this.characteristics.get(EMBER_CHARACTERISTICS.PUSH_EVENTS);
         if (pushEventsChar) {
             return new Promise((resolve, reject) => {
                 pushEventsChar.subscribe((error) => {
                     if (error) {
+                        debug('Error subscribing to push events:', error);
                         reject(error);
                         return;
                     }
+                    debug('Successfully subscribed to push events');
                     pushEventsChar.on('data', (data) => {
                         this.handlePushEvent(data);
                     });
@@ -200,30 +261,42 @@ export class BluetoothManager extends EventEmitter {
                 });
             });
         }
+        else {
+            debug('Push events characteristic not found, skipping notifications');
+        }
     }
     handlePushEvent(data) {
         const eventType = data[0];
+        debug(`Push event received: type=${eventType}`);
         switch (eventType) {
             case 1: // Battery changed
+                debug('Push event: Battery changed');
                 this.readBattery();
                 break;
             case 2: // Started charging
+                debug('Push event: Started charging');
                 this.state.isCharging = true;
                 this.emitState();
                 break;
             case 3: // Stopped charging
+                debug('Push event: Stopped charging');
                 this.state.isCharging = false;
                 this.emitState();
                 break;
             case 4: // Target temp changed
+                debug('Push event: Target temp changed');
                 this.readTargetTemp();
                 break;
             case 5: // Current temp changed
+                debug('Push event: Current temp changed');
                 this.readCurrentTemp();
                 break;
             case 8: // Liquid state changed
+                debug('Push event: Liquid state changed');
                 this.readLiquidState();
                 break;
+            default:
+                debug(`Push event: Unknown type ${eventType}`);
         }
     }
     async readInitialValues() {
@@ -246,13 +319,16 @@ export class BluetoothManager extends EventEmitter {
         }, 2000);
     }
     handleDisconnect() {
+        debug('Handling disconnect...');
         this.isConnected = false;
         this.state.connected = false;
         if (this.pollInterval) {
+            debug('Clearing polling interval');
             clearInterval(this.pollInterval);
             this.pollInterval = null;
         }
         this.characteristics.clear();
+        debug('Disconnect complete, emitting disconnected event');
         this.emit('disconnected');
         this.emitState();
     }

package/dist/lib/debug.d.ts

@@ -0,0 +1,3 @@
+export declare function setDebugMode(enabled: boolean): void;
+export declare function isDebugMode(): boolean;
+export declare function debug(message: string, ...args: unknown[]): void;

package/dist/lib/debug.js

@@ -0,0 +1,22 @@
+// Debug logging utility
+// When enabled, outputs detailed logs to stderr (so it doesn't interfere with Ink UI)
+let debugEnabled = false;
+export function setDebugMode(enabled) {
+    debugEnabled = enabled;
+    if (enabled) {
+        debug('Debug mode enabled');
+    }
+}
+export function isDebugMode() {
+    return debugEnabled;
+}
+export function debug(message, ...args) {
+    if (!debugEnabled)
+        return;
+    const timestamp = new Date().toISOString();
+    const formattedArgs = args.length > 0
+        ? ' ' + args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ')
+        : '';
+    // Write to stderr so it doesn't interfere with Ink's stdout rendering
+    process.stderr.write(`[${timestamp}] [DEBUG] ${message}${formattedArgs}\n`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-mug",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "A CLI app for controlling Ember mugs via Bluetooth",
   "type": "module",
   "main": "dist/index.js",