bitchat-node 0.1.1 → 0.1.2

package/src/client.ts

@@ -100,8 +100,9 @@ export class BitchatClient extends EventEmitter {
       this.running = true;
       this.emit('ready');
 
-      // Send initial announce
+      // Send initial announce and then periodic announces (like iOS does)
       setTimeout(() => this.sendAnnounce(), 1000);
+      setInterval(() => this.sendAnnounce(), 5000); // Every 5 seconds like iOS
     } catch (error) {
       this.emit('error', error as Error, 'start');
       throw error;
@@ -172,25 +173,47 @@ export class BitchatClient extends EventEmitter {
    */
   async sendPrivateMessage(content: string, toPeerID: PeerID): Promise<string> {
     const messageID = crypto.randomUUID();
+    const peerHex = toPeerID.toHex().slice(0, 8);
+
+    console.log(`[PM] Sending to ${peerHex}: "${content.slice(0, 30)}..."`);
 
     // Check if we have a session
     if (!this.sessions.hasSession(toPeerID)) {
-      // Need to establish session first
-      if (!this.sessions.hasHandshakeInProgress(toPeerID)) {
-        // Initiate handshake
-        const handshakeMsg = this.sessions.initiateHandshake(toPeerID);
-        await this.sendHandshakePacket(toPeerID, handshakeMsg);
+      console.log(`[PM] No session with ${peerHex}`);
+      
+      // Tie-breaker: only initiate if our peerID < target peerID
+      // This prevents both sides from initiating simultaneously
+      const weInitiate = this.peerID.toHex() < toPeerID.toHex();
+      console.log(`[PM] We initiate: ${weInitiate} (us: ${this.peerID.toHex().slice(0,8)} vs them: ${peerHex})`);
+      
+      if (weInitiate) {
+        // Need to establish session first
+        if (!this.sessions.hasHandshakeInProgress(toPeerID)) {
+          console.log(`[PM] Initiating handshake with ${peerHex}`);
+          // Initiate handshake
+          const handshakeMsg = this.sessions.initiateHandshake(toPeerID);
+          console.log(`[PM] Handshake message: ${handshakeMsg.length} bytes`);
+          await this.sendHandshakePacket(toPeerID, handshakeMsg);
+          console.log(`[PM] Handshake packet sent`);
+        } else {
+          console.log(`[PM] Handshake already in progress with ${peerHex}`);
+        }
+      } else {
+        console.log(`[PM] Waiting for ${peerHex} to initiate handshake (they have lower ID)`);
       }
 
       // Queue message for after handshake
       const payload = this.buildPrivateMessagePayload(content, messageID);
       this.sessions.queueMessage(toPeerID, payload);
+      console.log(`[PM] Message queued for after handshake`);
 
       return messageID;
     }
 
+    console.log(`[PM] Session exists, encrypting and sending`);
     // Encrypt and send
     await this.sendEncryptedMessage(toPeerID, content, messageID);
+    console.log(`[PM] Encrypted message sent`);
     return messageID;
   }
 
@@ -239,13 +262,22 @@ export class BitchatClient extends EventEmitter {
 
     // Session events
     this.sessions.on('session:established', (peerID: PeerID, _session: NoiseSession) => {
+      const peerHex = peerID.toHex().slice(0, 8);
+      console.log(`[Session] ✓ Established with ${peerHex}`);
       const peer = this.sessions.getPeerInfo(peerID);
       if (peer) {
         this.emit('peer:updated', peer);
       }
     });
 
+    this.sessions.on('session:failed', (peerID: PeerID, error: Error) => {
+      const peerHex = peerID.toHex().slice(0, 8);
+      console.log(`[Session] ✗ Failed with ${peerHex}:`, error.message);
+    });
+
     this.sessions.on('handshake:message', async (peerID: PeerID, encrypted: Uint8Array) => {
+      const peerHex = peerID.toHex().slice(0, 8);
+      console.log(`[Session] Flushing queued message to ${peerHex}: ${encrypted.length} bytes`);
       // Send queued encrypted message
       const packet: BitchatPacket = {
         version: 1,
@@ -258,6 +290,7 @@ export class BitchatClient extends EventEmitter {
         isRSR: false,
       };
       await this.router.sendToPeer(packet, peerID);
+      console.log(`[Session] Queued message sent`);
     });
   }
 
@@ -269,6 +302,11 @@ export class BitchatClient extends EventEmitter {
   }
 
   private handlePacket(packet: BitchatPacket, fromLink: BLELink | null): void {
+    // Ignore our own packets (echoed back through mesh)
+    if (packet.senderID.equals(this.peerID)) {
+      return;
+    }
+    
     switch (packet.type) {
       case MessageType.ANNOUNCE:
         this.handleAnnounce(packet, fromLink);
@@ -306,11 +344,13 @@ export class BitchatClient extends EventEmitter {
     // Verify signature if present
     if (packet.signature && announcement?.signingPublicKey) {
       const dataToSign = encodeForSigning(packet);
+      console.log('[Announce] Verifying', nickname, '- dataToSign first 60:', Buffer.from(dataToSign.slice(0, 60)).toString('hex'));
       const isValid = verify(dataToSign, packet.signature, announcement.signingPublicKey);
       if (!isValid) {
         console.warn('[Announce] Invalid signature from', nickname, peerID.toHex().slice(0, 8));
         return; // Reject invalid announces
       }
+      console.log('[Announce] Valid signature from', nickname);
     }
 
     // Check if this is a NEW peer or an existing one
@@ -329,7 +369,10 @@ export class BitchatClient extends EventEmitter {
 
     // Associate peer ID with link
     if (fromLink) {
+      console.log(`[Announce] Setting peer ${peerID.toHex().slice(0,8)} on link ${fromLink.id.slice(0,8)}`);
       fromLink.setPeerID(peerID);
+    } else {
+      console.log(`[Announce] No fromLink for peer ${peerID.toHex().slice(0,8)} - cannot associate!`);
     }
 
     const peer = this.sessions.getPeerInfo(peerID);
@@ -373,10 +416,16 @@ export class BitchatClient extends EventEmitter {
 
   private async handleHandshake(packet: BitchatPacket): Promise<void> {
     const peerID = packet.senderID;
+    const peerHex = peerID.toHex().slice(0, 8);
+    console.log(`[Handshake] Received from ${peerHex}: ${packet.payload.length} bytes`);
+    
     const response = this.sessions.handleHandshakeMessage(peerID, packet.payload);
 
     if (response) {
+      console.log(`[Handshake] Sending response to ${peerHex}: ${response.length} bytes`);
       await this.sendHandshakePacket(peerID, response);
+    } else {
+      console.log(`[Handshake] No response needed (complete or error)`);
     }
   }
 
@@ -385,39 +434,76 @@ export class BitchatClient extends EventEmitter {
 
     try {
       const decrypted = this.sessions.decrypt(peerID, packet.payload);
-
-      // First byte is payload type
-      const payloadType = decrypted[0] as NoisePayloadType;
-      const payloadData = decrypted.subarray(1);
-
-      switch (payloadType) {
-        case NoisePayloadType.PRIVATE_MESSAGE:
-          this.handlePrivateMessage(peerID, payloadData, packet.timestamp);
-          break;
-
-        case NoisePayloadType.READ_RECEIPT:
-          // TODO: Handle read receipt
-          break;
-
-        case NoisePayloadType.DELIVERED:
-          // TODO: Handle delivery confirmation
-          break;
-
-        default:
-          // Unknown payload type
-          break;
+      
+      console.log(`[Encrypted] Decrypted ${decrypted.length} bytes from ${peerID.toHex().slice(0, 8)}`);
+      console.log(`[Encrypted] First 20 bytes: ${Buffer.from(decrypted.slice(0, 20)).toString('hex')}`);
+
+      // Check payload type byte
+      const payloadType = decrypted[0];
+      
+      if (payloadType === NoisePayloadType.PRIVATE_MESSAGE) {
+        // TLV format: [0x01] [messageID TLV: 0x00, len, data] [content TLV: 0x01, len, data]
+        const tlvData = decrypted.subarray(1);
+        const parsed = this.parseTLVPrivateMessage(tlvData);
+        
+        if (parsed) {
+          console.log(`[Encrypted] Parsed TLV: msgID="${parsed.messageID.slice(0, 20)}...", content="${parsed.content.slice(0, 30)}..."`);
+          this.handlePrivateMessage(peerID, new TextEncoder().encode(parsed.content), packet.timestamp, parsed.messageID);
+        } else {
+          console.log(`[Encrypted] Failed to parse TLV, treating as raw`);
+          this.handlePrivateMessage(peerID, tlvData, packet.timestamp);
+        }
+      } else if (payloadType === NoisePayloadType.READ_RECEIPT) {
+        console.log(`[Encrypted] Read receipt from ${peerID.toHex().slice(0, 8)}`);
+        // TODO: Handle read receipt
+      } else if (payloadType === NoisePayloadType.DELIVERED) {
+        console.log(`[Encrypted] Delivery confirmation from ${peerID.toHex().slice(0, 8)}`);
+        // TODO: Handle delivery confirmation
+      } else {
+        console.log(`[Encrypted] Unknown payload type: 0x${payloadType.toString(16)}`);
       }
     } catch (error) {
       this.emit('error', error as Error, 'decrypt');
     }
   }
+  
+  private parseTLVPrivateMessage(data: Uint8Array): { messageID: string; content: string } | null {
+    let offset = 0;
+    let messageID: string | undefined;
+    let content: string | undefined;
+    
+    while (offset + 2 <= data.length) {
+      const tlvType = data[offset++];
+      const tlvLen = data[offset++];
+      
+      if (offset + tlvLen > data.length) break;
+      
+      const tlvValue = data.subarray(offset, offset + tlvLen);
+      offset += tlvLen;
+      
+      if (tlvType === 0x00) {
+        // messageID
+        messageID = new TextDecoder().decode(tlvValue);
+      } else if (tlvType === 0x01) {
+        // content
+        content = new TextDecoder().decode(tlvValue);
+      }
+    }
+    
+    if (messageID && content) {
+      return { messageID, content };
+    }
+    return null;
+  }
 
-  private handlePrivateMessage(senderID: PeerID, payload: Uint8Array, timestamp: bigint): void {
+  private handlePrivateMessage(senderID: PeerID, payload: Uint8Array, timestamp: bigint, messageID?: string): void {
     const content = new TextDecoder().decode(payload);
+    const id = messageID ?? `${senderID.toHex()}-${timestamp}-private`;
+    
     const peer = this.sessions.getPeerInfo(senderID);
 
     const message: ChatMessage = {
-      id: `${senderID.toHex()}-${timestamp}-private`,
+      id,
       sender: senderID,
       senderNickname: peer?.nickname ?? 'anon',
       content,
@@ -426,6 +512,7 @@ export class BitchatClient extends EventEmitter {
       deliveryStatus: { type: 'delivered', to: this.peerID, at: new Date() },
     };
 
+    console.log(`[PM] Received from ${peer?.nickname ?? 'anon'}: "${content.slice(0, 30)}..."`);
     this.emit('message', message);
   }
 
@@ -453,6 +540,13 @@ export class BitchatClient extends EventEmitter {
     const signature = sign(dataToSign, this.sessions.signingKeyPair.secretKey);
     packet.signature = signature;
 
+    // Debug: verify our own signature
+    const selfVerify = verify(dataToSign, signature, this.sessions.signingKeyPair.publicKey);
+    console.log('[Announce] Self-verify:', selfVerify ? 'PASS' : 'FAIL');
+    console.log('[Announce] DataToSign length:', dataToSign.length);
+    console.log('[Announce] DataToSign first 60:', Buffer.from(dataToSign.slice(0, 60)).toString('hex'));
+    console.log('[Announce] Signature:', Buffer.from(signature).toString('hex').slice(0, 40) + '...');
+
     await this.router.sendPacket(packet);
     const encoded = encode(packet);
     await this.transport.broadcast(encoded);
@@ -487,11 +581,42 @@ export class BitchatClient extends EventEmitter {
     await this.router.sendToPeer(packet, toPeerID);
   }
 
-  private buildPrivateMessagePayload(content: string, _messageID: string): Uint8Array {
-    const contentBytes = new TextEncoder().encode(content);
-    const payload = new Uint8Array(1 + contentBytes.length);
-    payload[0] = NoisePayloadType.PRIVATE_MESSAGE;
-    payload.set(contentBytes, 1);
+  private buildPrivateMessagePayload(content: string, messageID: string): Uint8Array {
+    // iOS TLV format:
+    // [0x01] - NoisePayloadType.privateMessage
+    // [0x00][len][messageID UTF8] - TLV for messageID
+    // [0x01][len][content UTF8] - TLV for content
+    const encoder = new TextEncoder();
+    const messageIDBytes = encoder.encode(messageID);
+    const contentBytes = encoder.encode(content);
+    
+    // Validate lengths (must fit in 1 byte)
+    if (messageIDBytes.length > 255 || contentBytes.length > 255) {
+      throw new Error('Message ID or content too long for TLV encoding');
+    }
+    
+    // Build TLV payload: 1 + (1+1+msgIDLen) + (1+1+contentLen)
+    const payload = new Uint8Array(1 + 2 + messageIDBytes.length + 2 + contentBytes.length);
+    let offset = 0;
+    
+    // NoisePayloadType.privateMessage = 0x01
+    payload[offset++] = 0x01;
+    
+    // TLV for messageID: type=0x00, length, data
+    payload[offset++] = 0x00;
+    payload[offset++] = messageIDBytes.length;
+    payload.set(messageIDBytes, offset);
+    offset += messageIDBytes.length;
+    
+    // TLV for content: type=0x01, length, data  
+    payload[offset++] = 0x01;
+    payload[offset++] = contentBytes.length;
+    payload.set(contentBytes, offset);
+    
+    console.log(`[PM] Building TLV payload: msgID="${messageID.slice(0, 20)}...", content="${content.slice(0, 20)}..."`);
+    console.log(`[PM] Total payload: ${payload.length} bytes`);
+    console.log(`[PM] First 50 bytes: ${Buffer.from(payload.slice(0, 50)).toString('hex')}`);
+    
     return payload;
   }
 

package/src/debug.ts

@@ -0,0 +1,119 @@
+/**
+ * Global debug logger for Bitchat
+ * Emits events that can be forwarded to UI/webhooks
+ */
+
+import { EventEmitter } from 'node:events';
+
+export interface DebugEvent {
+  category: 'ble-rx' | 'ble-tx' | 'session' | 'error' | 'packet' | 'pm';
+  tag?: string;
+  text?: string;
+  hex?: string;
+  decoded?: string;
+  time: number;
+}
+
+export interface SessionState {
+  peerID: string;
+  established: boolean;
+  initiator: boolean;
+  txNonce?: number;
+  rxNonce?: number;
+  error?: string;
+}
+
+class DebugLogger extends EventEmitter {
+  private enabled = true;
+  private logToConsole = true;
+
+  enable(): void {
+    this.enabled = true;
+  }
+
+  disable(): void {
+    this.enabled = false;
+  }
+
+  setConsoleLogging(enabled: boolean): void {
+    this.logToConsole = enabled;
+  }
+
+  log(event: Omit<DebugEvent, 'time'>): void {
+    if (!this.enabled) return;
+
+    const fullEvent: DebugEvent = {
+      ...event,
+      time: Date.now(),
+    };
+
+    this.emit('debug', fullEvent);
+
+    if (this.logToConsole) {
+      const tag = event.tag || event.category.toUpperCase();
+      const parts = [`[${tag}]`];
+      if (event.text) parts.push(event.text);
+      if (event.hex) parts.push(`hex: ${event.hex.slice(0, 60)}${event.hex.length > 60 ? '...' : ''}`);
+      if (event.decoded) parts.push(`→ ${event.decoded}`);
+      console.log(parts.join(' '));
+    }
+  }
+
+  // Convenience methods
+  bleRx(data: Uint8Array, decoded?: string): void {
+    this.log({
+      category: 'ble-rx',
+      tag: 'BLE RX',
+      hex: Buffer.from(data).toString('hex'),
+      decoded,
+    });
+  }
+
+  bleTx(data: Uint8Array, decoded?: string): void {
+    this.log({
+      category: 'ble-tx',
+      tag: 'BLE TX',
+      hex: Buffer.from(data).toString('hex'),
+      decoded,
+    });
+  }
+
+  session(peerID: string, text: string): void {
+    this.log({
+      category: 'session',
+      tag: 'Session',
+      text: `[${peerID.slice(0, 8)}] ${text}`,
+    });
+  }
+
+  packet(direction: 'rx' | 'tx', type: string, info: string): void {
+    this.log({
+      category: 'packet',
+      tag: `PKT ${direction.toUpperCase()}`,
+      text: `${type}: ${info}`,
+    });
+  }
+
+  pm(direction: 'rx' | 'tx', peerID: string, text: string): void {
+    this.log({
+      category: 'pm',
+      tag: `PM ${direction.toUpperCase()}`,
+      text: `[${peerID.slice(0, 8)}] ${text}`,
+    });
+  }
+
+  error(context: string, error: Error | string): void {
+    this.log({
+      category: 'error',
+      tag: 'ERROR',
+      text: `${context}: ${error instanceof Error ? error.message : error}`,
+    });
+  }
+
+  updateSession(state: SessionState): void {
+    this.emit('session', state);
+  }
+}
+
+// Global singleton
+export const debugLog = new DebugLogger();

package/src/index.ts

@@ -93,3 +93,14 @@ export {
   type BLETransportConfig,
   type BLETransportEvents,
 } from './transport/index.js';
+
+// UI Server
+export {
+  startUIServer,
+  type UIServerConfig,
+  type DebugEvent,
+  type SessionState,
+} from './ui/server.js';
+
+// Debug
+export { debugLog } from './debug.js';

package/src/mesh/router.ts

@@ -231,15 +231,25 @@ export class MeshRouter extends EventEmitter {
    * Send to a specific peer (if we have a direct link)
    */
   async sendToPeer(packet: BitchatPacket, peerID: PeerID): Promise<boolean> {
+    const peerHex = peerID.toHex().slice(0, 8);
+    
     // Find link for this peer
-    const link = Array.from(this.links.values()).find((l) => l.peerID?.equals(peerID));
+    const allLinks = Array.from(this.links.values());
+    console.log(`[Router] sendToPeer ${peerHex}: ${allLinks.length} links available`);
+    allLinks.forEach((l, i) => {
+      console.log(`[Router]   Link ${i}: id=${l.id.slice(0,8)}, peerID=${l.peerID?.toHex().slice(0,8) ?? 'none'}`);
+    });
+    
+    const link = allLinks.find((l) => l.peerID?.equals(peerID));
 
     if (!link) {
+      console.log(`[Router] No direct link to ${peerHex}, broadcasting instead`);
       // No direct link - broadcast and hope for relay
       await this.sendPacket(packet);
       return false;
     }
 
+    console.log(`[Router] Found direct link to ${peerHex}, sending directly`);
     const { encode } = await import('../protocol/binary.js');
     const data = encode(packet);
     await link.send(data);

package/src/protocol/binary.ts

@@ -326,11 +326,11 @@ function decodeCore(data: Uint8Array): BitchatPacket | null {
 /**
  * Create binary representation for signing (without signature, TTL=0)
  */
-export function encodeForSigning(packet: BitchatPacket): Uint8Array {
+export function encodeForSigning(packet: BitchatPacket, preserveTTL = false): Uint8Array {
   const unsigned: BitchatPacket = {
     ...packet,
     signature: undefined,
-    ttl: 0,
+    ttl: preserveTTL ? packet.ttl : 0,  // Some implementations preserve TTL for verification
     isRSR: false,
   };
   // Must use padding: true to match Swift's toBinaryDataForSigning()

package/src/session/manager.ts

@@ -16,6 +16,7 @@ import {
 } from '../crypto/noise.js';
 import { fingerprint, generateSigningKeyPair, type SigningKeyPair } from '../crypto/signing.js';
 import { HandshakeState, PeerID, type PeerInfo } from '../protocol/types.js';
+import { debugLog } from '../debug.js';
 
 // Key persistence path
 const KEY_DIR = join(homedir(), '.bitchat-node');
@@ -290,8 +291,17 @@ export class SessionManager extends EventEmitter {
     }
 
     // Create session
-    const { send, receive, hash } = pending.state.split();
+    // iOS uses useExtractedNonce: true (4-byte nonce prepended to ciphertext)
+    const { send, receive, hash } = pending.state.split(true);
     const session = new NoiseSession(send, receive, hash, remotePublicKey);
+    debugLog.session(peerID.toHex(), `Session established (${pending.role}, extracted nonce mode)`);
+    debugLog.updateSession({
+      peerID: peerID.toHex(),
+      established: true,
+      initiator: pending.role === 'initiator',
+      txNonce: 0,
+      rxNonce: 0,
+    });
 
     // Store session
     this.sessions.set(key, {
@@ -327,6 +337,14 @@ export class SessionManager extends EventEmitter {
     const key = peerID.toHex();
     const pending = this.pendingHandshakes.get(key);
 
+    debugLog.session(key, `Handshake failed: ${error.message}`);
+    debugLog.updateSession({
+      peerID: key,
+      established: false,
+      initiator: pending?.role === 'initiator',
+      error: error.message,
+    });
+
     if (pending?.timeoutHandle) {
       clearTimeout(pending.timeoutHandle);
     }