bitchat-node 0.1.0

package/src/transport/ble.ts

@@ -0,0 +1,553 @@
+/**
+ * BLE Transport
+ * Handles Bluetooth Low Energy communication for Bitchat mesh
+ *
+ * Uses noble for central mode (scanning/connecting) and
+ * bleno for peripheral mode (advertising/accepting)
+ */
+
+import { EventEmitter } from 'node:events';
+import type { Link } from '../mesh/router.js';
+import {
+  BLE_MAX_MTU,
+  CHARACTERISTIC_UUID,
+  SERVICE_UUID,
+  SERVICE_UUID_TESTNET,
+} from '../protocol/constants.js';
+import type { PeerID } from '../protocol/types.js';
+
+// Types for noble
+type NobleModule = typeof import('@abandonware/noble');
+type Peripheral = import('@abandonware/noble').Peripheral;
+type Characteristic = import('@abandonware/noble').Characteristic;
+
+// Types for bleno
+type BlenoModule = typeof import('@abandonware/bleno');
+
+export interface BLETransportConfig {
+  serviceUUID: string;
+  characteristicUUID: string;
+  testnet: boolean;
+  enableCentral: boolean;
+  enablePeripheral: boolean;
+  scanDuplicates: boolean;
+  advertisingName?: string;
+}
+
+const DEFAULT_CONFIG: BLETransportConfig = {
+  serviceUUID: SERVICE_UUID,
+  characteristicUUID: CHARACTERISTIC_UUID,
+  testnet: false,
+  enableCentral: true,
+  enablePeripheral: true,
+  scanDuplicates: true, // Enable to allow reconnection attempts
+};
+
+interface ConnectedPeripheral {
+  peripheral: Peripheral;
+  characteristic?: Characteristic;
+  peerID?: PeerID;
+  mtu: number;
+}
+
+export interface BLETransportEvents {
+  ready: () => void;
+  data: (data: Uint8Array, fromLink: BLELink) => void;
+  'link:connected': (link: BLELink) => void;
+  'link:disconnected': (linkId: string) => void;
+  error: (error: Error, context: string) => void;
+  state: (state: string) => void;
+}
+
+/**
+ * BLE link implementation
+ */
+export class BLELink implements Link {
+  readonly id: string;
+  private peripheral: Peripheral;
+  private characteristic: Characteristic;
+  private _peerID?: PeerID;
+  private mtu: number;
+
+  constructor(peripheral: Peripheral, characteristic: Characteristic, mtu: number = BLE_MAX_MTU) {
+    this.id = peripheral.uuid;
+    this.peripheral = peripheral;
+    this.characteristic = characteristic;
+    this.mtu = mtu;
+  }
+
+  get peerID(): PeerID | undefined {
+    return this._peerID;
+  }
+
+  setPeerID(peerID: PeerID): void {
+    this._peerID = peerID;
+  }
+
+  async send(data: Uint8Array): Promise<void> {
+    // Fragment if necessary
+    if (data.length > this.mtu) {
+      // TODO: Implement fragmentation
+      throw new Error('Message too large for MTU, fragmentation not yet implemented');
+    }
+
+    console.log('[BLE] Sending', data.length, 'bytes to', this.id);
+    console.log('[BLE] First 50 bytes:', Buffer.from(data.slice(0, 50)).toString('hex'));
+    console.log('[BLE] Last 20 bytes:', Buffer.from(data.slice(-20)).toString('hex'));
+
+    const buf = Buffer.from(data);
+    console.log('[BLE] Buffer check - is Buffer:', Buffer.isBuffer(buf), 'length:', buf.length);
+
+    // Try write WITHOUT response (withoutResponse = true)
+    // This uses a different BLE write type that might work better
+    return new Promise((resolve, reject) => {
+      this.characteristic.write(buf, true, (error) => {
+        if (error) {
+          console.error('[BLE] Send error:', error);
+          reject(error);
+        } else {
+          console.log('[BLE] Send success (without response)');
+          resolve();
+        }
+      });
+    });
+  }
+
+  get isConnected(): boolean {
+    return this.peripheral.state === 'connected';
+  }
+}
+
+/**
+ * BLE Transport - handles Bluetooth mesh networking
+ */
+export class BLETransport extends EventEmitter {
+  private config: BLETransportConfig;
+  private noble?: NobleModule;
+  private bleno?: BlenoModule;
+  private running = false;
+
+  // Connected peripherals (central mode)
+  private peripherals = new Map<string, ConnectedPeripheral>();
+  private links = new Map<string, BLELink>();
+
+  // Subscribed centrals (peripheral mode)
+  private subscribedCentrals = new Set<string>();
+  private notifyCallback?: (data: Buffer) => void;
+
+  constructor(config: Partial<BLETransportConfig> = {}) {
+    super();
+    const baseConfig = { ...DEFAULT_CONFIG, ...config };
+    // Use testnet UUID if testnet is true and no explicit serviceUUID was provided
+    if (baseConfig.testnet && !config.serviceUUID) {
+      baseConfig.serviceUUID = SERVICE_UUID_TESTNET;
+    }
+    this.config = baseConfig;
+    console.log(
+      '[BLE] Config: testnet =',
+      this.config.testnet,
+      ', serviceUUID =',
+      this.config.serviceUUID
+    );
+  }
+
+  /**
+   * Start the BLE transport
+   */
+  async start(): Promise<void> {
+    if (this.running) return;
+
+    try {
+      // Initialize central mode (noble)
+      if (this.config.enableCentral) {
+        await this.initCentral();
+      }
+
+      // Initialize peripheral mode (bleno)
+      if (this.config.enablePeripheral) {
+        await this.initPeripheral();
+      }
+
+      this.running = true;
+      this.emit('ready');
+    } catch (error) {
+      this.emit('error', error as Error, 'start');
+      throw error;
+    }
+  }
+
+  /**
+   * Stop the BLE transport
+   */
+  async stop(): Promise<void> {
+    if (!this.running) return;
+
+    try {
+      // Stop scanning
+      if (this.noble) {
+        await this.noble.stopScanningAsync();
+      }
+
+      // Stop advertising
+      if (this.bleno) {
+        this.bleno.stopAdvertising();
+      }
+
+      // Disconnect all peripherals
+      for (const [, conn] of this.peripherals) {
+        try {
+          await conn.peripheral.disconnectAsync();
+        } catch {
+          // Ignore disconnect errors
+        }
+      }
+
+      this.peripherals.clear();
+      this.links.clear();
+      this.subscribedCentrals.clear();
+      this.running = false;
+    } catch (error) {
+      this.emit('error', error as Error, 'stop');
+      throw error;
+    }
+  }
+
+  /**
+   * Get all active links
+   */
+  getLinks(): BLELink[] {
+    return Array.from(this.links.values());
+  }
+
+  /**
+   * Get link by ID
+   */
+  getLink(id: string): BLELink | undefined {
+    return this.links.get(id);
+  }
+
+  /**
+   * Broadcast data to all connected peers
+   */
+  async broadcast(data: Uint8Array): Promise<void> {
+    // Send via central mode (noble) links
+    const sendPromises = Array.from(this.links.values()).map(async (link) => {
+      try {
+        await link.send(data);
+      } catch (error) {
+        this.emit('error', error as Error, `broadcast to ${link.id}`);
+      }
+    });
+
+    // Send via peripheral mode (bleno) notifications
+    if (this.notifyCallback) {
+      try {
+        console.log('[BLE] Notifying subscribed centrals,', data.length, 'bytes');
+        this.notifyCallback(Buffer.from(data));
+      } catch (error) {
+        console.error('[BLE] Notify error:', error);
+        this.emit('error', error as Error, 'notify');
+      }
+    } else {
+      console.log('[BLE] No notify callback (no centrals subscribed)');
+    }
+
+    await Promise.allSettled(sendPromises);
+  }
+
+  // --- Central Mode (Noble) ---
+
+  private async initCentral(): Promise<void> {
+    console.log('[BLE] Initializing central mode (noble)...');
+    const nobleModule = await import('@abandonware/noble');
+    this.noble = nobleModule.default;
+    console.log('[BLE] Noble imported, state:', (this.noble as any).state);
+
+    // Wait for powered on
+    await this.waitForPoweredOn();
+    console.log('[BLE] Noble powered on');
+
+    // Set up event handlers
+    this.noble.on('discover', (peripheral) => this.onDiscover(peripheral));
+    this.noble.on('stateChange', (state) => this.emit('state', state));
+
+    // Start scanning
+    console.log('[BLE] Starting scan for service:', this.config.serviceUUID);
+    await this.noble.startScanningAsync([this.config.serviceUUID], this.config.scanDuplicates);
+    console.log('[BLE] Scanning started');
+  }
+
+  private async waitForPoweredOn(): Promise<void> {
+    if (!this.noble) throw new Error('Noble not initialized');
+
+    const noble = this.noble as any;
+    if (noble.state === 'poweredOn') return;
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error('Bluetooth adapter timeout'));
+      }, 10000);
+
+      const handler = (state: string) => {
+        if (state === 'poweredOn') {
+          clearTimeout(timeout);
+          noble.removeListener('stateChange', handler);
+          resolve();
+        } else if (state === 'poweredOff' || state === 'unauthorized') {
+          clearTimeout(timeout);
+          reject(new Error(`Bluetooth state: ${state}`));
+        }
+      };
+
+      noble.on('stateChange', handler);
+    });
+  }
+
+  // Track failed connection attempts for retry logic
+  private failedConnections = new Map<string, { count: number; lastAttempt: Date }>();
+  // Track peripherals currently being connected to (prevent duplicate attempts)
+  private connectingPeripherals = new Set<string>();
+
+  private async onDiscover(peripheral: Peripheral): Promise<void> {
+    // Skip verbose logging for repeated discoveries
+    const isRepeatedDiscovery =
+      this.failedConnections.has(peripheral.uuid) ||
+      this.peripherals.has(peripheral.uuid) ||
+      this.connectingPeripherals.has(peripheral.uuid);
+    if (!isRepeatedDiscovery) {
+      console.log(
+        '[BLE] Discovered peripheral:',
+        peripheral.uuid,
+        peripheral.advertisement?.localName
+      );
+    }
+
+    // Skip if already connected
+    if (this.peripherals.has(peripheral.uuid)) return;
+
+    // Skip if currently connecting (prevents duplicate connect attempts)
+    if (this.connectingPeripherals.has(peripheral.uuid)) return;
+
+    // If we have a working peripheral connection (someone subscribed to us),
+    // don't spam central connection attempts - mesh protocol doesn't need bidirectional
+    if (this.notifyCallback && this.links.size === 0) {
+      // We have a working inbound connection, don't need outbound
+      return;
+    }
+
+    // Check if we've failed too recently
+    const failed = this.failedConnections.get(peripheral.uuid);
+    if (failed) {
+      const backoffMs = Math.min(60000, 2000 * 2 ** failed.count); // Longer backoff
+      const elapsed = Date.now() - failed.lastAttempt.getTime();
+      if (elapsed < backoffMs) {
+        // Don't log every skip - too noisy
+        return;
+      }
+    }
+
+    // Mark as connecting to prevent duplicate attempts
+    this.connectingPeripherals.add(peripheral.uuid);
+
+    try {
+      console.log('[BLE] Connecting to', peripheral.uuid);
+      await peripheral.connectAsync();
+      console.log('[BLE] Connected to', peripheral.uuid);
+
+      // Clear tracking state on success
+      this.connectingPeripherals.delete(peripheral.uuid);
+      this.failedConnections.delete(peripheral.uuid);
+
+      // Discover services and characteristics
+      console.log('[BLE] Discovering services for', peripheral.uuid);
+      const { characteristics } = await peripheral.discoverSomeServicesAndCharacteristicsAsync(
+        [this.config.serviceUUID],
+        [this.config.characteristicUUID]
+      );
+      console.log('[BLE] Found', characteristics.length, 'characteristics');
+
+      if (characteristics.length === 0) {
+        console.log('[BLE] No characteristics found, disconnecting');
+        await peripheral.disconnectAsync();
+        return;
+      }
+
+      const characteristic = characteristics[0];
+
+      // Get MTU
+      const mtu = peripheral.mtu ?? BLE_MAX_MTU;
+      console.log('[BLE] Peripheral MTU:', peripheral.mtu, '(using:', `${mtu})`);
+
+      // Store connection
+      const conn: ConnectedPeripheral = {
+        peripheral,
+        characteristic,
+        mtu,
+      };
+      this.peripherals.set(peripheral.uuid, conn);
+
+      // Create link
+      const link = new BLELink(peripheral, characteristic, mtu);
+      this.links.set(peripheral.uuid, link);
+
+      // Subscribe to notifications
+      await characteristic.subscribeAsync();
+      characteristic.on('data', (data: Buffer) => {
+        this.emit('data', new Uint8Array(data), link);
+      });
+
+      // Handle disconnect
+      peripheral.once('disconnect', () => {
+        this.onDisconnect(peripheral.uuid);
+      });
+
+      this.emit('link:connected', link);
+    } catch (error) {
+      // Clear connecting state
+      this.connectingPeripherals.delete(peripheral.uuid);
+
+      const err = error as Error;
+
+      // Track failure for retry backoff
+      const failed = this.failedConnections.get(peripheral.uuid) ?? {
+        count: 0,
+        lastAttempt: new Date(),
+      };
+      failed.count++;
+      failed.lastAttempt = new Date();
+      this.failedConnections.set(peripheral.uuid, failed);
+
+      // Only log first few failures, then go quiet
+      if (failed.count <= 3) {
+        console.error(
+          '[BLE] Connection failed:',
+          err?.message ?? 'unknown error',
+          `(attempt ${failed.count})`
+        );
+      }
+
+      // Try to disconnect if still connected
+      try {
+        if (peripheral.state === 'connected' || peripheral.state === 'connecting') {
+          await peripheral.disconnectAsync();
+        }
+      } catch {}
+
+      // Only emit error for first failure
+      if (failed.count === 1) {
+        this.emit('error', err ?? new Error('Unknown BLE discover error'), 'discover');
+      }
+    }
+  }
+
+  private onDisconnect(peripheralUUID: string): void {
+    this.peripherals.delete(peripheralUUID);
+    this.links.delete(peripheralUUID);
+    this.emit('link:disconnected', peripheralUUID);
+  }
+
+  // --- Peripheral Mode (Bleno) ---
+
+  private async initPeripheral(): Promise<void> {
+    try {
+      const blenoModule = await import('@abandonware/bleno');
+      this.bleno = blenoModule.default;
+
+      // Wait for powered on
+      await this.waitForBlenoPoweredOn();
+
+      // Create characteristic
+      const CharacteristicClass = this.bleno.Characteristic;
+      const characteristic = new CharacteristicClass({
+        uuid: this.config.characteristicUUID.replace(/-/g, ''),
+        properties: ['read', 'write', 'writeWithoutResponse', 'notify'],
+        onWriteRequest: (
+          data: Buffer,
+          _offset: number,
+          _withoutResponse: boolean,
+          callback: (result: number) => void
+        ) => {
+          // Handle incoming data from central
+          this.emit('data', new Uint8Array(data), null as any);
+          callback(CharacteristicClass.RESULT_SUCCESS);
+        },
+        onSubscribe: (_maxValueSize: number, updateValueCallback: (data: Buffer) => void) => {
+          // Central subscribed to notifications - store callback
+          this.notifyCallback = updateValueCallback;
+          console.log('Central subscribed to notifications');
+        },
+        onUnsubscribe: () => {
+          // Central unsubscribed
+          this.notifyCallback = undefined;
+          console.log('Central unsubscribed');
+        },
+      });
+
+      // Create service
+      const PrimaryServiceClass = this.bleno.PrimaryService;
+      const service = new PrimaryServiceClass({
+        uuid: this.config.serviceUUID.replace(/-/g, ''),
+        characteristics: [characteristic],
+      });
+
+      // Set services
+      this.bleno.setServices([service]);
+
+      // Listen for central connection events
+      const bleno = this.bleno as any;
+      bleno.on('accept', (clientAddress: string) => {
+        console.log('[BLE] Central accepted connection from:', clientAddress);
+      });
+      bleno.on('disconnect', (clientAddress: string) => {
+        console.log('[BLE] Central disconnected:', clientAddress);
+      });
+      bleno.on('servicesSet', (error?: Error) => {
+        console.log('[BLE] Services set, error:', error);
+      });
+      bleno.on('advertisingStart', (error?: Error) => {
+        console.log('[BLE] Advertising started, error:', error);
+      });
+
+      // Start advertising
+      const name = this.config.advertisingName ?? 'bitchat';
+      this.bleno.startAdvertising(name, [this.config.serviceUUID]);
+    } catch (error) {
+      // Bleno might not be available on all platforms
+      console.warn('Bleno (peripheral mode) not available:', error);
+    }
+  }
+
+  private async waitForBlenoPoweredOn(): Promise<void> {
+    if (!this.bleno) throw new Error('Bleno not initialized');
+
+    const bleno = this.bleno as any;
+    if (bleno.state === 'poweredOn') return;
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error('Bleno timeout'));
+      }, 10000);
+
+      const handler = (state: string) => {
+        if (state === 'poweredOn') {
+          clearTimeout(timeout);
+          bleno.removeListener('stateChange', handler);
+          resolve();
+        } else if (state === 'poweredOff' || state === 'unauthorized') {
+          clearTimeout(timeout);
+          reject(new Error(`Bleno state: ${state}`));
+        }
+      };
+
+      bleno.on('stateChange', handler);
+    });
+  }
+
+  /**
+   * Clean up
+   */
+  destroy(): void {
+    this.stop().catch(() => {});
+    this.removeAllListeners();
+  }
+}

package/src/transport/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Transport module exports
+ */
+
+export {
+  BLELink,
+  BLETransport,
+  type BLETransportConfig,
+  type BLETransportEvents,
+} from './ble.js';

package/src/ui/index.ts

@@ -0,0 +1 @@
+export { startUIServer, type UIServerConfig } from './server.js';