@sym-bot/sym 0.1.0 → 0.2.1

package/lib/node.js

@@ -9,6 +9,9 @@ const { nodeDir, loadOrCreateIdentity, ensureDir, log: logMsg } = require('./con
 const { MemoryStore } = require('./memory-store');
 const { FrameParser, sendFrame } = require('./frame-parser');
 const { encode, DIM } = require('./context-encoder');
+const { TcpTransport, RelayPeerTransport } = require('./transport');
+const fs = require('fs');
+const { createSign } = require('crypto');
 
 /**
  * SymNode — a sovereign mesh node with cognitive coupling.
@@ -47,6 +50,24 @@ class SymNode extends EventEmitter {
     this._port = 0;
     this._running = false;
 
+    // Relay
+    this._relayUrl = opts.relay || null;
+    this._relayToken = opts.relayToken || null;
+    this._relayOnly = opts.relayOnly || false;
+    this._relayWs = null;
+    this._relayReconnectTimer = null;
+    this._relayReconnectDelay = 1000;
+    this._relayPeerTransports = new Map(); // nodeId → RelayPeerTransport
+
+    // Wake
+    this._wakeChannel = opts.wakeChannel || null; // { platform, token, environment }
+    this._peerWakeChannels = new Map(); // nodeId → { platform, token, environment }
+    this._wakeCooldownMs = opts.wakeCooldownMs || 5 * 60 * 1000; // 5 min default
+    this._peerLastWake = new Map(); // nodeId → timestamp
+    this._pendingFrames = new Map(); // nodeId → [frames] — queued for woken peers
+    this._wakeChannelsFile = path.join(this._dir, 'wake-channels.json');
+    this._loadWakeChannels();
+
     // Timers
     this._heartbeatInterval = opts.heartbeatInterval || 5000;
     this._heartbeatTimeout = opts.heartbeatTimeout || 15000;
@@ -77,6 +98,38 @@ class SymNode extends EventEmitter {
     return parts.join('\n');
   }
 
+  // ── Wake Channel Persistence ───────────────────────────────
+
+  /** Load persisted peer wake channels from disk. */
+  _loadWakeChannels() {
+    try {
+      if (fs.existsSync(this._wakeChannelsFile)) {
+        const data = JSON.parse(fs.readFileSync(this._wakeChannelsFile, 'utf8'));
+        for (const [id, ch] of Object.entries(data)) {
+          if (ch?.platform && ch?.token) {
+            this._peerWakeChannels.set(id, ch);
+          }
+        }
+        if (this._peerWakeChannels.size > 0) {
+          this._log(`Loaded ${this._peerWakeChannels.size} wake channel(s) from disk`);
+        }
+      }
+    } catch (err) {
+      this._log(`Failed to load wake channels: ${err.message}`);
+    }
+  }
+
+  /** Persist peer wake channels to disk. */
+  _saveWakeChannels() {
+    try {
+      ensureDir(path.dirname(this._wakeChannelsFile));
+      const data = Object.fromEntries(this._peerWakeChannels);
+      fs.writeFileSync(this._wakeChannelsFile, JSON.stringify(data, null, 2));
+    } catch (err) {
+      this._log(`Failed to save wake channels: ${err.message}`);
+    }
+  }
+
   _reencodeAndBroadcast() {
     const context = this._buildContext();
     if (context.length < 5) return;
@@ -122,7 +175,7 @@ class SymNode extends EventEmitter {
         this._log(`Not sharing with ${peer.name} — rejected (drift: ${d.drift.toFixed(3)})`);
         continue;
       }
-      sendFrame(peer.socket, { type: 'memory-share', ...entry });
+      peer.transport.send({ type: 'memory-share', ...entry });
       shared++;
       if (d) {
         this._log(`Shared with ${peer.name} — ${d.decision} (drift: ${d.drift.toFixed(3)})`);
@@ -139,13 +192,19 @@ class SymNode extends EventEmitter {
     if (this._running) return;
     this._running = true;
 
-    await this._startServer();
-    this._startDiscovery();
+    if (!this._relayOnly) {
+      await this._startServer();
+      this._startDiscovery();
+    }
+
+    if (this._relayUrl) {
+      this._connectRelay();
+    }
 
     this._heartbeatTimer = setInterval(() => this._checkHeartbeats(), this._heartbeatInterval);
     this._encodeTimer = setInterval(() => this._reencodeAndBroadcast(), this._encodeInterval);
 
-    this._log(`Started (port: ${this._port}, id: ${this._identity.nodeId.slice(0, 8)})`);
+    this._log(`Started (port: ${this._port}, id: ${this._identity.nodeId.slice(0, 8)}${this._relayUrl ? ', relay: ' + this._relayUrl : ''})`);
   }
 
   async stop() {
@@ -154,9 +213,21 @@ class SymNode extends EventEmitter {
 
     if (this._heartbeatTimer) clearInterval(this._heartbeatTimer);
     if (this._encodeTimer) clearInterval(this._encodeTimer);
+    if (this._relayReconnectTimer) clearTimeout(this._relayReconnectTimer);
+
+    // Close relay transports
+    for (const [, transport] of this._relayPeerTransports) {
+      transport.destroy();
+    }
+    this._relayPeerTransports.clear();
+
+    if (this._relayWs) {
+      try { this._relayWs.close(); } catch {}
+      this._relayWs = null;
+    }
 
     for (const [, peer] of this._peers) {
-      try { peer.socket.destroy(); } catch {}
+      peer.transport.close();
     }
     this._peers.clear();
 
@@ -184,7 +255,6 @@ class SymNode extends EventEmitter {
     this._meshNode.updateLocalState(h1, h2, 0.8);
 
     // Evaluate coupling with each peer — only share with aligned/guarded
-    // Trigger coupling evaluation
     this._meshNode.coupledState();
     const decisions = this._meshNode.couplingDecisions;
 
@@ -197,7 +267,7 @@ class SymNode extends EventEmitter {
         continue;
       }
 
-      sendFrame(peer.socket, { type: 'memory-share', ...entry });
+      peer.transport.send({ type: 'memory-share', ...entry });
       shared++;
 
       if (d) {
@@ -231,6 +301,10 @@ class SymNode extends EventEmitter {
       timestamp: Date.now(),
     };
     this._broadcastToPeers(frame);
+
+    // Wake sleeping peers and queue the frame for delivery on reconnect
+    this._wakeSleepingPeers('mood', frame);
+
     this._log(`Mood broadcast: "${mood.slice(0, 50)}"`);
   }
 
@@ -246,12 +320,195 @@ class SymNode extends EventEmitter {
     };
     if (opts.to) {
       const peer = this._peers.get(opts.to);
-      if (peer) sendFrame(peer.socket, frame);
+      if (peer) peer.transport.send(frame);
     } else {
       this._broadcastToPeers(frame);
     }
   }
 
+  // ── Wake ────────────────────────────────────────────────────
+
+  /**
+   * Wake a sleeping peer via push notification.
+   * Autonomous decision: checks transport, coupling, cooldown.
+   */
+  async wakeIfNeeded(peerId, reason = 'message') {
+    // 1. Is peer transport active?
+    const peer = this._peers.get(peerId);
+    if (peer?.transport) return false; // peer is connected, no wake needed
+
+    // 2. Does peer have a wake channel?
+    const wakeChannel = this._peerWakeChannels.get(peerId);
+    if (!wakeChannel || wakeChannel.platform === 'none') return false;
+
+    // 3. Is peer coupled? (autonomous decision)
+    const d = this._meshNode.couplingDecisions.get(peerId);
+    if (d && d.decision === 'rejected') return false;
+
+    // 4. Cooldown check
+    const lastWake = this._peerLastWake.get(peerId) || 0;
+    if (Date.now() - lastWake < this._wakeCooldownMs) return false;
+
+    // 5. Send wake
+    try {
+      await this._sendWake(wakeChannel, reason);
+      this._peerLastWake.set(peerId, Date.now());
+      this._log(`Wake sent to ${peerId}: ${reason} via ${wakeChannel.platform}`);
+      return true;
+    } catch (err) {
+      this._log(`Wake failed for ${peerId}: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Wake all sleeping coupled peers.
+   */
+  async wakeAllPeers(reason = 'message') {
+    const promises = [];
+    for (const [peerId] of this._peerWakeChannels) {
+      promises.push(this.wakeIfNeeded(peerId, reason));
+    }
+    const results = await Promise.allSettled(promises);
+    return results.filter(r => r.status === 'fulfilled' && r.value).length;
+  }
+
+  /**
+   * Attempt to wake all sleeping peers that have wake channels
+   * but no active transport. Queues the frame for delivery on reconnect.
+   */
+  _wakeSleepingPeers(reason, pendingFrame) {
+    for (const [peerId] of this._peerWakeChannels) {
+      if (!this._peers.has(peerId)) {
+        // Queue frame for delivery when this peer reconnects
+        if (pendingFrame) {
+          if (!this._pendingFrames.has(peerId)) {
+            this._pendingFrames.set(peerId, []);
+          }
+          this._pendingFrames.get(peerId).push(pendingFrame);
+        }
+
+        this.wakeIfNeeded(peerId, reason).catch(err => {
+          this._log(`Wake failed for ${peerId.slice(0, 8)}: ${err.message}`);
+        });
+      }
+    }
+  }
+
+  /** Route wake to the appropriate platform transport. */
+  async _sendWake(wakeChannel, reason) {
+    switch (wakeChannel.platform) {
+      case 'apns':
+        return this._sendAPNsWake(wakeChannel, reason);
+      default:
+        throw new Error(`Unsupported wake platform: ${wakeChannel.platform}`);
+    }
+  }
+
+  /**
+   * Send an APNs push notification to wake a sleeping iOS node.
+   *
+   * Uses JWT (ES256) authentication with a p8 key from ~/.sym/wake-keys/.
+   * Sends a visible alert (iOS throttles silent pushes making them unreliable).
+   * The content-available flag triggers background processing on delivery.
+   */
+  async _sendAPNsWake(wakeChannel, reason) {
+    const http2 = require('http2');
+    const keysDir = path.join(require('os').homedir(), '.sym', 'wake-keys');
+    const configPath = path.join(keysDir, 'apns-config.json');
+    const keyPath = path.join(keysDir, 'apns-key.p8');
+
+    // Load and cache APNs credentials on first use
+    if (!this._apnsConfig) {
+      if (!fs.existsSync(configPath) || !fs.existsSync(keyPath)) {
+        throw new Error('APNs keys not found at ~/.sym/wake-keys/ (need apns-key.p8 + apns-config.json)');
+      }
+      this._apnsConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      this._apnsKey = fs.readFileSync(keyPath, 'utf8');
+
+      if (!this._apnsConfig.teamId || !this._apnsConfig.keyId || !this._apnsConfig.bundleId) {
+        this._apnsConfig = null;
+        throw new Error('apns-config.json must have teamId, keyId, and bundleId');
+      }
+    }
+
+    const { teamId, keyId, bundleId } = this._apnsConfig;
+
+    // Build JWT (ES256) — valid for up to 1 hour per Apple spec
+    const header = Buffer.from(JSON.stringify({ alg: 'ES256', kid: keyId })).toString('base64url');
+    const iat = Math.floor(Date.now() / 1000);
+    const claims = Buffer.from(JSON.stringify({ iss: teamId, iat })).toString('base64url');
+    const signer = createSign('SHA256');
+    signer.update(`${header}.${claims}`);
+    const signature = signer.sign({ key: this._apnsKey, dsaEncoding: 'ieee-p1363' }, 'base64url');
+    const jwt = `${header}.${claims}.${signature}`;
+
+    // APNs requires HTTP/2 — Node.js fetch does not support it
+    const host = wakeChannel.environment === 'sandbox'
+      ? 'api.sandbox.push.apple.com'
+      : 'api.push.apple.com';
+
+    // Visible alert with content-available for background processing
+    const reasonText = {
+      mood: 'shared a mood signal',
+      message: 'sent a message',
+      memory: 'shared a memory',
+    }[reason] || 'wants to connect';
+
+    const payload = JSON.stringify({
+      aps: {
+        alert: { title: 'SYM Mesh', body: `${this.name}: ${reasonText}` },
+        'content-available': 1,
+        sound: 'default',
+      },
+      mmp: {
+        type: 'wake',
+        from: this._identity.nodeId,
+        fromName: this.name,
+        reason,
+      },
+    });
+
+    return new Promise((resolve, reject) => {
+      const client = http2.connect(`https://${host}`);
+
+      client.on('error', (err) => {
+        client.close();
+        reject(new Error(`APNs connection failed: ${err.message}`));
+      });
+
+      const req = client.request({
+        ':method': 'POST',
+        ':path': `/3/device/${wakeChannel.token}`,
+        'authorization': `bearer ${jwt}`,
+        'apns-topic': bundleId,
+        'apns-push-type': 'alert',
+        'apns-priority': '10',
+      });
+
+      let status;
+      let body = '';
+
+      req.on('response', (headers) => { status = headers[':status']; });
+      req.on('data', (chunk) => { body += chunk; });
+      req.on('end', () => {
+        client.close();
+        if (status === 200) {
+          resolve();
+        } else {
+          reject(new Error(`APNs responded ${status}: ${body}`));
+        }
+      });
+      req.on('error', (err) => {
+        client.close();
+        reject(new Error(`APNs request failed: ${err.message}`));
+      });
+
+      req.write(payload);
+      req.end();
+    });
+  }
+
   // ── Monitoring ─────────────────────────────────────────────
 
   peers() {
@@ -266,6 +523,7 @@ class SymNode extends EventEmitter {
         lastSeen: peer.lastSeen,
         coupling: d ? d.decision : 'pending',
         drift: d ? parseFloat(d.drift.toFixed(3)) : null,
+        source: peer.source || 'bonjour',
       });
     }
     return result;
@@ -285,6 +543,8 @@ class SymNode extends EventEmitter {
       nodeId: this._identity.nodeId.slice(0, 8),
       running: this._running,
       port: this._port,
+      relay: this._relayUrl || null,
+      relayConnected: this._relayWs?.readyState === 1 || false,
       peers: this.peers(),
       peerCount: this._peers.size,
       memoryCount: this.memories(),
@@ -311,24 +571,30 @@ class SymNode extends EventEmitter {
   }
 
   _handleInboundConnection(socket) {
-    const parser = new FrameParser();
+    const transport = new TcpTransport(socket);
     let identified = false;
-    const timeout = setTimeout(() => { if (!identified) socket.destroy(); }, 10000);
+    const timeout = setTimeout(() => { if (!identified) transport.close(); }, 10000);
 
-    socket.on('data', (chunk) => { if (!identified) parser.feed(chunk); });
-
-    parser.on('message', (msg) => {
+    transport.on('message', (msg) => {
       if (identified) return;
-      if (msg.type !== 'handshake') { socket.destroy(); return; }
+      if (msg.type !== 'handshake') { transport.close(); return; }
       identified = true;
       clearTimeout(timeout);
-      if (this._peers.has(msg.nodeId)) { socket.destroy(); return; }
-      const peer = this._createPeer(socket, msg.nodeId, msg.name, false);
-      if (parser.buffer.length > 0) peer.parser.feed(parser.buffer);
+      if (this._peers.has(msg.nodeId)) { transport.close(); return; }
+
+      // Re-wire transport messages to peer handler
+      transport.removeAllListeners('message');
+      transport.on('message', (m) => {
+        const peer = this._peers.get(msg.nodeId);
+        if (peer) peer.lastSeen = Date.now();
+        this._handlePeerMessage(msg.nodeId, msg.name, m);
+      });
+
+      const peer = this._createPeer(transport, msg.nodeId, msg.name, false, 'bonjour');
       this._addPeer(peer);
     });
 
-    socket.on('error', () => clearTimeout(timeout));
+    transport.on('error', () => clearTimeout(timeout));
   }
 
   // ── Bonjour Discovery ──────────────────────────────────────
@@ -362,46 +628,204 @@ class SymNode extends EventEmitter {
   _connectToPeer(address, port, peerId, peerName) {
     if (this._peers.has(peerId)) return;
     const socket = net.createConnection({ host: address, port }, () => {
-      const peer = this._createPeer(socket, peerId, peerName, true);
+      const transport = new TcpTransport(socket);
+      transport.on('message', (msg) => {
+        const peer = this._peers.get(peerId);
+        if (peer) peer.lastSeen = Date.now();
+        this._handlePeerMessage(peerId, peerName, msg);
+      });
+      transport.on('error', () => {});
+      const peer = this._createPeer(transport, peerId, peerName, true, 'bonjour');
       this._addPeer(peer);
     });
     socket.on('error', (err) => this._log(`Connect failed to ${peerName}: ${err.message}`));
     socket.setTimeout(10000, () => socket.destroy());
   }
 
-  // ── Peer Management ────────────────────────────────────────
+  // ── WebSocket Relay ─────────────────────────────────────────
+
+  _connectRelay() {
+    if (!this._running || !this._relayUrl) return;
+
+    let WebSocket;
+    try {
+      WebSocket = require('ws');
+    } catch {
+      this._log('Relay requires the "ws" package — npm install ws');
+      return;
+    }
+
+    const ws = new WebSocket(this._relayUrl);
+    this._relayWs = ws;
+
+    ws.on('open', () => {
+      this._relayReconnectDelay = 1000;
+      this._log(`Relay connected: ${this._relayUrl}`);
+
+      // Authenticate with the relay
+      const auth = {
+        type: 'relay-auth',
+        nodeId: this._identity.nodeId,
+        name: this.name,
+        wakeChannel: this._wakeChannel || undefined,
+      };
+      if (this._relayToken) auth.token = this._relayToken;
+      ws.send(JSON.stringify(auth));
+    });
+
+    ws.on('message', (data) => {
+      let msg;
+      try { msg = JSON.parse(data.toString()); } catch { return; }
+
+      if (msg.type === 'relay-peer-joined') {
+        this._handleRelayPeerJoined(msg.nodeId, msg.name);
+      } else if (msg.type === 'relay-peer-left') {
+        this._handleRelayPeerLeft(msg.nodeId, msg.name);
+      } else if (msg.type === 'relay-peers') {
+        // Initial peer list from relay — includes gossip (wake channels)
+        for (const p of (msg.peers || [])) {
+          // Store gossiped wake channels
+          if (p.wakeChannel && p.wakeChannel.platform !== 'none') {
+            this._peerWakeChannels.set(p.nodeId, p.wakeChannel);
+            this._log(`Gossip: learned wake channel for ${p.name} (${p.wakeChannel.platform})`);
+          }
+          // Only connect to online peers
+          if (!p.offline) {
+            this._handleRelayPeerJoined(p.nodeId, p.name);
+          }
+        }
+        this._saveWakeChannels();
+      } else if (msg.type === 'relay-ping') {
+        ws.send(JSON.stringify({ type: 'relay-pong' }));
+      } else if (msg.type === 'relay-error') {
+        this._log(`Relay error: ${msg.message}`);
+      } else if (msg.from && msg.payload) {
+        // Routed frame from a peer
+        const peer = this._peers.get(msg.from);
+        if (peer) peer.lastSeen = Date.now();
+        this._handlePeerMessage(msg.from, msg.fromName || 'unknown', msg.payload);
+      }
+    });
+
+    ws.on('close', () => {
+      this._log('Relay disconnected');
+      this._relayWs = null;
+
+      // Clean up relay peers
+      for (const [peerId, peer] of this._peers) {
+        if (peer.source === 'relay') {
+          this._peers.delete(peerId);
+          this._meshNode.removePeer(peerId);
+          this.emit('peer-left', { id: peerId, name: peer.name });
+        }
+      }
+      for (const [, transport] of this._relayPeerTransports) {
+        transport.destroy();
+      }
+      this._relayPeerTransports.clear();
 
-  _createPeer(socket, peerId, peerName, isOutbound) {
-    const parser = new FrameParser();
-    socket.on('data', (chunk) => parser.feed(chunk));
-    parser.on('message', (msg) => {
-      const peer = this._peers.get(peerId);
-      if (peer) peer.lastSeen = Date.now();
-      this._handlePeerMessage(peerId, peerName, msg);
+      this._scheduleRelayReconnect();
     });
-    parser.on('error', (err) => this._log(`Frame error from ${peerName}: ${err.message}`));
-    socket.on('close', () => {
+
+    ws.on('error', (err) => {
+      this._log(`Relay error: ${err.message}`);
+    });
+  }
+
+  _handleRelayPeerJoined(peerId, peerName) {
+    if (!peerId || peerId === this._identity.nodeId) return;
+    if (this._peers.has(peerId)) return; // Already connected (via Bonjour or relay)
+
+    const transport = new RelayPeerTransport(this._relayWs, peerId);
+    this._relayPeerTransports.set(peerId, transport);
+
+    transport.on('close', () => {
+      this._relayPeerTransports.delete(peerId);
+    });
+
+    const peer = this._createPeer(transport, peerId, peerName, true, 'relay');
+    this._addPeer(peer);
+  }
+
+  _handleRelayPeerLeft(peerId, peerName) {
+    const peer = this._peers.get(peerId);
+    if (!peer || peer.source !== 'relay') return;
+
+    const transport = this._relayPeerTransports.get(peerId);
+    if (transport) transport.destroy();
+    this._relayPeerTransports.delete(peerId);
+
+    this._peers.delete(peerId);
+    this._meshNode.removePeer(peerId);
+    this._log(`Relay peer left: ${peerName || peerId}`);
+    this.emit('peer-left', { id: peerId, name: peerName || peer.name });
+  }
+
+  _scheduleRelayReconnect() {
+    if (!this._running || !this._relayUrl) return;
+
+    const jitter = this._relayReconnectDelay * 0.1 * Math.random();
+    const delay = this._relayReconnectDelay + jitter;
+
+    this._log(`Relay reconnecting in ${Math.round(delay / 1000)}s`);
+    this._relayReconnectTimer = setTimeout(() => this._connectRelay(), delay);
+
+    // Exponential backoff, capped at 30s
+    this._relayReconnectDelay = Math.min(this._relayReconnectDelay * 2, 30000);
+  }
+
+  // ── Peer Management ────────────────────────────────────────
+
+  _createPeer(transport, peerId, peerName, isOutbound, source) {
+    transport.on('close', () => {
       this._peers.delete(peerId);
       this._meshNode.removePeer(peerId);
       this._log(`Peer disconnected: ${peerName}`);
       this.emit('peer-left', { id: peerId, name: peerName });
     });
-    socket.on('error', () => {});
-    return { socket, parser, peerId, name: peerName, isOutbound, lastSeen: Date.now() };
+
+    return { transport, peerId, name: peerName, isOutbound, source, lastSeen: Date.now() };
   }
 
   _addPeer(peer) {
     this._peers.set(peer.peerId, peer);
 
     // Handshake
-    sendFrame(peer.socket, { type: 'handshake', nodeId: this._identity.nodeId, name: this.name });
+    peer.transport.send({ type: 'handshake', nodeId: this._identity.nodeId, name: this.name });
 
     // Send cognitive state for coupling evaluation
     const [h1, h2] = this._meshNode.coupledState();
-    sendFrame(peer.socket, { type: 'state-sync', h1, h2, confidence: 0.8 });
+    peer.transport.send({ type: 'state-sync', h1, h2, confidence: 0.8 });
+
+    // Send wake channel if configured (legacy, for backward compat)
+    if (this._wakeChannel) {
+      peer.transport.send({ type: 'wake-channel', ...this._wakeChannel });
+    }
 
-    this._log(`Peer connected: ${peer.name} (${peer.isOutbound ? 'outbound' : 'inbound'})`);
+    // Send peer-info gossip — share what we know about other peers
+    const knownPeers = [];
+    for (const [id, wc] of this._peerWakeChannels) {
+      if (id !== peer.peerId) {
+        const peerEntry = this._peers.get(id);
+        knownPeers.push({ nodeId: id, name: peerEntry?.name || 'unknown', wakeChannel: wc, lastSeen: Date.now() });
+      }
+    }
+    if (knownPeers.length > 0) {
+      peer.transport.send({ type: 'peer-info', peers: knownPeers });
+    }
+
+    this._log(`Peer connected: ${peer.name} (${peer.isOutbound ? 'outbound' : 'inbound'}, ${peer.source})`);
     this.emit('peer-joined', { id: peer.peerId, name: peer.name });
+
+    // Deliver any frames queued while this peer was sleeping
+    const pending = this._pendingFrames.get(peer.peerId);
+    if (pending && pending.length > 0) {
+      this._log(`Delivering ${pending.length} pending frame(s) to ${peer.name}`);
+      for (const frame of pending) {
+        peer.transport.send(frame);
+      }
+      this._pendingFrames.delete(peer.peerId);
+    }
   }
 
   _handlePeerMessage(peerId, peerName, msg) {
@@ -464,15 +888,41 @@ class SymNode extends EventEmitter {
         }
         break;
 
+      case 'wake-channel':
+        if (msg.platform) {
+          this._peerWakeChannels.set(peerId, {
+            platform: msg.platform,
+            token: msg.token,
+            environment: msg.environment,
+          });
+          this._saveWakeChannels();
+          this._log(`Wake channel from ${peerName}: ${msg.platform}`);
+        }
+        break;
+
+      case 'peer-info':
+        // Gossip: peer is sharing what it knows about other peers
+        if (Array.isArray(msg.peers)) {
+          for (const p of msg.peers) {
+            if (p.nodeId && p.wakeChannel && p.nodeId !== this._identity.nodeId) {
+              this._peerWakeChannels.set(p.nodeId, p.wakeChannel);
+              this._log(`Gossip from ${peerName}: learned wake channel for ${p.name}`);
+            }
+          }
+          this._saveWakeChannels();
+        }
+        break;
+
       case 'message':
         this._log(`Message from ${msg.fromName || peerName}: ${(msg.content || '').slice(0, 60)}`);
         this.emit('message', msg.fromName || peerName, msg.content, msg);
         break;
 
-      case 'ping':
+      case 'ping': {
         const peer = this._peers.get(peerId);
-        if (peer) sendFrame(peer.socket, { type: 'pong' });
+        if (peer) peer.transport.send({ type: 'pong' });
         break;
+      }
 
       case 'pong':
         break;
@@ -481,7 +931,7 @@ class SymNode extends EventEmitter {
 
   _broadcastToPeers(frame) {
     for (const [, peer] of this._peers) {
-      sendFrame(peer.socket, frame);
+      peer.transport.send(frame);
     }
   }
 
@@ -490,11 +940,11 @@ class SymNode extends EventEmitter {
     for (const [id, peer] of this._peers) {
       if (now - peer.lastSeen > this._heartbeatTimeout) {
         this._log(`Heartbeat timeout: ${peer.name}`);
-        peer.socket.destroy();
+        peer.transport.close();
         this._peers.delete(id);
         this._meshNode.removePeer(id);
       } else if (now - peer.lastSeen > this._heartbeatInterval) {
-        sendFrame(peer.socket, { type: 'ping' });
+        peer.transport.send({ type: 'ping' });
       }
     }
   }