bitchat-node 0.1.0

package/src/bin/bitchat.ts

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+/**
+ * Bitchat Node CLI
+ * Run a Bitchat mesh node with web UI
+ */
+
+import { BitchatClient } from '../client.js';
+import { startUIServer } from '../ui/server.js';
+
+const args = process.argv.slice(2);
+const nickname =
+  args.find((a) => a.startsWith('--nickname='))?.split('=')[1] ??
+  args.find((a) => a.startsWith('-n='))?.split('=')[1] ??
+  process.env.BITCHAT_NICKNAME ??
+  `node-${Math.random().toString(36).slice(2, 6)}`;
+
+const port = parseInt(
+  args.find((a) => a.startsWith('--port='))?.split('=')[1] ??
+    args.find((a) => a.startsWith('-p='))?.split('=')[1] ??
+    process.env.BITCHAT_PORT ??
+    '3939',
+  10
+);
+
+const testnet = args.includes('--testnet');
+
+console.log('Starting Bitchat Node...');
+console.log(`  Nickname: ${nickname}`);
+console.log(`  Port: ${port}`);
+console.log(`  Network: ${testnet ? 'testnet' : 'mainnet'}`);
+console.log();
+
+const client = new BitchatClient({
+  nickname,
+  testnet,
+});
+
+// Event logging
+client.on('ready', () => {
+  console.log(`✓ Ready`);
+  console.log(`  Peer ID: ${client.peerID.toHex()}`);
+  console.log(`  Fingerprint: ${client.fingerprint}`);
+  console.log();
+});
+
+client.on('peer:connected', (peer) => {
+  console.log(`+ Peer: ${peer.nickname} (${peer.peerID.toHex().slice(0, 8)}...)`);
+});
+
+client.on('peer:disconnected', (peerID) => {
+  console.log(`- Peer: ${peerID.toHex().slice(0, 8)}...`);
+});
+
+client.on('message', (msg) => {
+  const prefix = msg.isPrivate ? '[DM]' : '[PUB]';
+  console.log(`${prefix} ${msg.senderNickname}: ${msg.content}`);
+});
+
+client.on('error', (err, ctx) => {
+  console.error(`! Error (${ctx}): ${err.message}`);
+});
+
+// Start
+async function main() {
+  try {
+    await client.start();
+
+    const ui = startUIServer(client, { port });
+    console.log(`\n🌐 Web UI: http://localhost:${port}\n`);
+
+    // Graceful shutdown
+    const shutdown = async () => {
+      console.log('\nShutting down...');
+      ui.stop();
+      await client.stop();
+      process.exit(0);
+    };
+
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+  } catch (error) {
+    console.error('Failed to start:', error);
+    process.exit(1);
+  }
+}
+
+main();

package/src/client.ts

@@ -0,0 +1,519 @@
+/**
+ * Bitchat Client
+ * High-level API for Bitchat mesh networking
+ */
+
+import { EventEmitter } from 'node:events';
+import type { NoiseKeyPair, NoiseSession } from './crypto/noise.js';
+import { type SigningKeyPair, sign, verify } from './crypto/signing.js';
+import { type Link, MeshRouter } from './mesh/router.js';
+import { decode, encode, encodeForSigning, makeDeduplicationID } from './protocol/binary.js';
+import { DEFAULT_TTL } from './protocol/constants.js';
+import { decodeAnnouncement, encodeAnnouncement } from './protocol/packets.js';
+import {
+  type BitchatPacket,
+  type ChatMessage,
+  MessageType,
+  NoisePayloadType,
+  type PeerID,
+  type PeerInfo,
+} from './protocol/types.js';
+import { SessionManager } from './session/manager.js';
+import { type BLELink, BLETransport } from './transport/ble.js';
+
+export interface BitchatClientConfig {
+  nickname: string;
+  staticKeyPair?: NoiseKeyPair;
+  signingKeyPair?: SigningKeyPair;
+  testnet?: boolean;
+}
+
+export interface BitchatClientEvents {
+  ready: () => void;
+  message: (message: ChatMessage) => void;
+  'peer:connected': (peer: PeerInfo) => void;
+  'peer:disconnected': (peerID: PeerID) => void;
+  'peer:updated': (peer: PeerInfo) => void;
+  error: (error: Error, context: string) => void;
+}
+
+/**
+ * Bitchat mesh network client
+ */
+export class BitchatClient extends EventEmitter {
+  private readonly config: BitchatClientConfig;
+  private readonly transport: BLETransport;
+  private readonly router: MeshRouter;
+  private readonly sessions: SessionManager;
+  private running = false;
+
+  // Our identity
+  readonly nickname: string;
+  readonly peerID: PeerID;
+  readonly fingerprint: string;
+
+  /** Get the client configuration */
+  getConfig(): BitchatClientConfig {
+    return this.config;
+  }
+
+  constructor(config: BitchatClientConfig) {
+    super();
+    this.config = config;
+    this.nickname = config.nickname;
+
+    // Initialize session manager (handles keys and Noise sessions)
+    this.sessions = new SessionManager(
+      {},
+      {
+        static: config.staticKeyPair,
+        signing: config.signingKeyPair,
+      }
+    );
+
+    this.peerID = this.sessions.myPeerID;
+    this.fingerprint = this.sessions.fingerprint;
+
+    // Initialize router
+    this.router = new MeshRouter();
+    this.router.setMyPeerID(this.peerID);
+
+    // Initialize transport
+    this.transport = new BLETransport({
+      testnet: config.testnet ?? false,
+    });
+
+    // Wire up event handlers
+    this.setupEventHandlers();
+  }
+
+  /**
+   * Start the client
+   */
+  async start(): Promise<void> {
+    if (this.running) return;
+
+    try {
+      // Start transport
+      await this.transport.start();
+
+      this.running = true;
+      this.emit('ready');
+
+      // Send initial announce
+      setTimeout(() => this.sendAnnounce(), 1000);
+    } catch (error) {
+      this.emit('error', error as Error, 'start');
+      throw error;
+    }
+  }
+
+  /**
+   * Stop the client
+   */
+  async stop(): Promise<void> {
+    if (!this.running) return;
+
+    try {
+      // Send leave message
+      await this.sendLeave();
+
+      // Stop transport
+      await this.transport.stop();
+
+      // Clean up
+      this.router.destroy();
+      this.sessions.destroy();
+
+      this.running = false;
+    } catch (error) {
+      this.emit('error', error as Error, 'stop');
+      throw error;
+    }
+  }
+
+  /**
+   * Send a public message to the mesh
+   */
+  async sendPublicMessage(content: string): Promise<string> {
+    console.log('[Client] sendPublicMessage:', content);
+    const messageID = crypto.randomUUID();
+    const timestamp = BigInt(Date.now());
+
+    const packet: BitchatPacket = {
+      version: 1,
+      type: MessageType.MESSAGE,
+      ttl: DEFAULT_TTL,
+      timestamp,
+      senderID: this.peerID,
+      payload: new TextEncoder().encode(content),
+      isRSR: false,
+    };
+
+    // Sign the packet
+    const dataToSign = encodeForSigning(packet);
+    const signature = sign(dataToSign, this.sessions.signingKeyPair.secretKey);
+    packet.signature = signature;
+
+    // Send via router (to noble links) and transport (to bleno subscribers)
+    console.log('[Client] Sending to router...');
+    await this.router.sendPacket(packet);
+    console.log('[Client] Encoding packet...');
+    const encoded = encode(packet);
+    console.log('[Client] Broadcasting via transport, size:', encoded.length);
+    await this.transport.broadcast(encoded);
+    console.log('[Client] Broadcast complete');
+
+    return messageID;
+  }
+
+  /**
+   * Send a private message to a specific peer
+   */
+  async sendPrivateMessage(content: string, toPeerID: PeerID): Promise<string> {
+    const messageID = crypto.randomUUID();
+
+    // 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);
+      }
+
+      // Queue message for after handshake
+      const payload = this.buildPrivateMessagePayload(content, messageID);
+      this.sessions.queueMessage(toPeerID, payload);
+
+      return messageID;
+    }
+
+    // Encrypt and send
+    await this.sendEncryptedMessage(toPeerID, content, messageID);
+    return messageID;
+  }
+
+  /**
+   * Get list of connected peers
+   */
+  getConnectedPeers(): PeerInfo[] {
+    return this.sessions.getAllPeers().filter((p) => p.isConnected);
+  }
+
+  /**
+   * Get peer info
+   */
+  getPeerInfo(peerID: PeerID): PeerInfo | undefined {
+    return this.sessions.getPeerInfo(peerID);
+  }
+
+  // --- Private methods ---
+
+  private setupEventHandlers(): void {
+    // Transport events
+    this.transport.on('ready', () => {
+      // Add links to router as they're discovered
+    });
+
+    this.transport.on('link:connected', (link: BLELink) => {
+      this.router.addLink(link);
+    });
+
+    this.transport.on('link:disconnected', (linkId: string) => {
+      this.router.removeLink(linkId);
+    });
+
+    this.transport.on('data', (data: Uint8Array, link: BLELink) => {
+      this.handleIncomingData(data, link);
+    });
+
+    this.transport.on('error', (error: Error, context: string) => {
+      this.emit('error', error, `transport:${context}`);
+    });
+
+    // Router events
+    this.router.on('packet', (packet: BitchatPacket, fromLink: Link | null) => {
+      this.handlePacket(packet, fromLink as BLELink | null);
+    });
+
+    // Session events
+    this.sessions.on('session:established', (peerID: PeerID, _session: NoiseSession) => {
+      const peer = this.sessions.getPeerInfo(peerID);
+      if (peer) {
+        this.emit('peer:updated', peer);
+      }
+    });
+
+    this.sessions.on('handshake:message', async (peerID: PeerID, encrypted: Uint8Array) => {
+      // Send queued encrypted message
+      const packet: BitchatPacket = {
+        version: 1,
+        type: MessageType.NOISE_ENCRYPTED,
+        ttl: DEFAULT_TTL,
+        timestamp: BigInt(Date.now()),
+        senderID: this.peerID,
+        recipientID: peerID,
+        payload: encrypted,
+        isRSR: false,
+      };
+      await this.router.sendToPeer(packet, peerID);
+    });
+  }
+
+  private async handleIncomingData(data: Uint8Array, link: BLELink): Promise<void> {
+    const packet = decode(data);
+    if (!packet) return;
+
+    await this.router.handlePacket(packet, link);
+  }
+
+  private handlePacket(packet: BitchatPacket, fromLink: BLELink | null): void {
+    switch (packet.type) {
+      case MessageType.ANNOUNCE:
+        this.handleAnnounce(packet, fromLink);
+        break;
+
+      case MessageType.MESSAGE:
+        this.handlePublicMessage(packet);
+        break;
+
+      case MessageType.LEAVE:
+        this.handleLeave(packet);
+        break;
+
+      case MessageType.NOISE_HANDSHAKE:
+        this.handleHandshake(packet);
+        break;
+
+      case MessageType.NOISE_ENCRYPTED:
+        this.handleEncrypted(packet);
+        break;
+
+      default:
+        // Unknown type - already relayed by router
+        break;
+    }
+  }
+
+  private handleAnnounce(packet: BitchatPacket, fromLink: BLELink | null): void {
+    const peerID = packet.senderID;
+
+    // Decode TLV announcement payload
+    const announcement = decodeAnnouncement(packet.payload);
+    const nickname = announcement?.nickname ?? 'anon';
+
+    // Verify signature if present
+    if (packet.signature && announcement?.signingPublicKey) {
+      const dataToSign = encodeForSigning(packet);
+      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
+      }
+    }
+
+    // Check if this is a NEW peer or an existing one
+    const existingPeer = this.sessions.getPeerInfo(peerID);
+    const isNewPeer = !existingPeer || !existingPeer.isConnected;
+
+    // Update peer info
+    this.sessions.updatePeerInfo(peerID, {
+      nickname,
+      isConnected: true,
+      lastSeen: new Date(),
+      // Store keys if available
+      noisePublicKey: announcement?.noisePublicKey,
+      signingPublicKey: announcement?.signingPublicKey,
+    });
+
+    // Associate peer ID with link
+    if (fromLink) {
+      fromLink.setPeerID(peerID);
+    }
+
+    const peer = this.sessions.getPeerInfo(peerID);
+    if (peer) {
+      // Only emit 'peer:connected' for NEW peers, not repeat announces
+      if (isNewPeer) {
+        this.emit('peer:connected', peer);
+      } else {
+        // Existing peer sent another announce - just update internally
+        this.emit('peer:updated', peer);
+      }
+    }
+  }
+
+  private handlePublicMessage(packet: BitchatPacket): void {
+    const content = new TextDecoder().decode(packet.payload);
+    const peer = this.sessions.getPeerInfo(packet.senderID);
+
+    const message: ChatMessage = {
+      id: makeDeduplicationID(packet),
+      sender: packet.senderID,
+      senderNickname: peer?.nickname ?? 'anon',
+      content,
+      timestamp: new Date(Number(packet.timestamp)),
+      isPrivate: false,
+      deliveryStatus: { type: 'delivered', to: this.peerID, at: new Date() },
+    };
+
+    this.emit('message', message);
+  }
+
+  private handleLeave(packet: BitchatPacket): void {
+    const peerID = packet.senderID;
+
+    this.sessions.updatePeerInfo(peerID, {
+      isConnected: false,
+    });
+
+    this.emit('peer:disconnected', peerID);
+  }
+
+  private async handleHandshake(packet: BitchatPacket): Promise<void> {
+    const peerID = packet.senderID;
+    const response = this.sessions.handleHandshakeMessage(peerID, packet.payload);
+
+    if (response) {
+      await this.sendHandshakePacket(peerID, response);
+    }
+  }
+
+  private handleEncrypted(packet: BitchatPacket): void {
+    const peerID = packet.senderID;
+
+    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;
+      }
+    } catch (error) {
+      this.emit('error', error as Error, 'decrypt');
+    }
+  }
+
+  private handlePrivateMessage(senderID: PeerID, payload: Uint8Array, timestamp: bigint): void {
+    const content = new TextDecoder().decode(payload);
+    const peer = this.sessions.getPeerInfo(senderID);
+
+    const message: ChatMessage = {
+      id: `${senderID.toHex()}-${timestamp}-private`,
+      sender: senderID,
+      senderNickname: peer?.nickname ?? 'anon',
+      content,
+      timestamp: new Date(Number(timestamp)),
+      isPrivate: true,
+      deliveryStatus: { type: 'delivered', to: this.peerID, at: new Date() },
+    };
+
+    this.emit('message', message);
+  }
+
+  private async sendAnnounce(): Promise<void> {
+    // Encode announcement with TLV format
+    const payload = encodeAnnouncement({
+      nickname: this.nickname,
+      noisePublicKey: this.sessions.staticKeyPair.publicKey,
+      signingPublicKey: this.sessions.signingKeyPair.publicKey,
+      directNeighbors: this.router.getConnectedPeerIDs().map((p) => p.toBytes()),
+    });
+
+    const packet: BitchatPacket = {
+      version: 1,
+      type: MessageType.ANNOUNCE,
+      ttl: DEFAULT_TTL,
+      timestamp: BigInt(Date.now()),
+      senderID: this.peerID,
+      payload,
+      isRSR: false,
+    };
+
+    // Sign the announce packet
+    const dataToSign = encodeForSigning(packet);
+    const signature = sign(dataToSign, this.sessions.signingKeyPair.secretKey);
+    packet.signature = signature;
+
+    await this.router.sendPacket(packet);
+    const encoded = encode(packet);
+    await this.transport.broadcast(encoded);
+  }
+
+  private async sendLeave(): Promise<void> {
+    const packet: BitchatPacket = {
+      version: 1,
+      type: MessageType.LEAVE,
+      ttl: DEFAULT_TTL,
+      timestamp: BigInt(Date.now()),
+      senderID: this.peerID,
+      payload: new Uint8Array(0),
+      isRSR: false,
+    };
+
+    await this.router.sendPacket(packet);
+  }
+
+  private async sendHandshakePacket(toPeerID: PeerID, message: Uint8Array): Promise<void> {
+    const packet: BitchatPacket = {
+      version: 1,
+      type: MessageType.NOISE_HANDSHAKE,
+      ttl: DEFAULT_TTL,
+      timestamp: BigInt(Date.now()),
+      senderID: this.peerID,
+      recipientID: toPeerID,
+      payload: message,
+      isRSR: false,
+    };
+
+    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);
+    return payload;
+  }
+
+  private async sendEncryptedMessage(
+    toPeerID: PeerID,
+    content: string,
+    messageID: string
+  ): Promise<void> {
+    const payload = this.buildPrivateMessagePayload(content, messageID);
+    const encrypted = this.sessions.encrypt(toPeerID, payload);
+
+    const packet: BitchatPacket = {
+      version: 1,
+      type: MessageType.NOISE_ENCRYPTED,
+      ttl: DEFAULT_TTL,
+      timestamp: BigInt(Date.now()),
+      senderID: this.peerID,
+      recipientID: toPeerID,
+      payload: encrypted,
+      isRSR: false,
+    };
+
+    await this.router.sendToPeer(packet, toPeerID);
+  }
+}

package/src/crypto/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Crypto module exports
+ */
+
+export {
+  CipherState,
+  generateKeyPair,
+  HandshakeState,
+  type NoiseKeyPair,
+  type NoiseRole,
+  NoiseSession,
+} from './noise.js';
+
+export {
+  fingerprint,
+  formatFingerprint,
+  generateSigningKeyPair,
+  type SigningKeyPair,
+  sha256,
+  sign,
+  verify,
+} from './signing.js';