pal-explorer-cli 0.4.7 → 0.4.8

package/lib/core/syncTransport.js

@@ -0,0 +1,203 @@
+import zlib from 'zlib';
+import { promisify } from 'util';
+import { sendAuthenticatedRequest } from './signalingServer.js';
+import { selectBestTransport, TRANSPORT } from './streamTransport.js';
+import { getNearbyPeers } from './mdnsService.js';
+import { getPrimaryServer } from './discoveryClient.js';
+import config from '../utils/config.js';
+import logger from '../utils/logger.js';
+
+const gzip = promisify(zlib.gzip);
+const gunzip = promisify(zlib.gunzip);
+
+// Base transport class — all sync transports implement send() and sendFile()
+class SyncTransportBase {
+  constructor(type) {
+    this.type = type;
+  }
+  async send(envelope) { throw new Error('Not implemented'); }
+  async sendFile(filePath, relativePath, opts) { throw new Error('Not implemented'); }
+  async sendChunk(data) { throw new Error('Not implemented'); }
+  close() {}
+}
+
+// LAN transport — send PAL/1.0 envelopes via signaling server TCP (port 7474)
+export class LanTransport extends SyncTransportBase {
+  constructor(peerAddress) {
+    super('lan');
+    const [host, port] = peerAddress.split(':');
+    this.host = host;
+    this.port = parseInt(port, 10) || 7474;
+  }
+
+  async send(envelope) {
+    const identity = config.get('identity');
+    if (!identity?.privateKey || !identity?.publicKey) {
+      throw new Error('Identity not configured');
+    }
+    const result = await sendAuthenticatedRequest(
+      this.host, this.port,
+      { type: 'message', envelope },
+      identity.privateKey, identity.publicKey, 10000
+    );
+    if (result.error) throw new Error(result.error);
+    return result;
+  }
+
+  async sendFile(readStream, relativePath, { onChunk } = {}) {
+    // File data is sent as sync.request response chunks via the same TCP protocol
+    // For LAN, we embed file data in the envelope payload (chunked for large files)
+    const chunks = [];
+    for await (const chunk of readStream) {
+      chunks.push(chunk);
+      if (onChunk) onChunk(chunk.length);
+    }
+    return Buffer.concat(chunks);
+  }
+}
+
+// WebRTC transport — send via WebRTC data channel (for internet peers)
+export class WebRTCTransport extends SyncTransportBase {
+  constructor(iceServers, localPK, remotePK) {
+    super('webrtc');
+    this.iceServers = iceServers;
+    this.localPK = localPK;
+    this.remotePK = remotePK;
+    this.dataChannel = null;
+  }
+
+  async send(envelope) {
+    if (!this.dataChannel) {
+      throw new Error('WebRTC data channel not established');
+    }
+    const data = JSON.stringify(envelope);
+    this.dataChannel.send(data);
+    return { received: true };
+  }
+
+  async sendChunk(data) {
+    if (!this.dataChannel) {
+      throw new Error('WebRTC data channel not established');
+    }
+    // 16KB chunks with backpressure
+    const CHUNK_SIZE = 16384;
+    for (let offset = 0; offset < data.length; offset += CHUNK_SIZE) {
+      const chunk = data.subarray(offset, offset + CHUNK_SIZE);
+      while (this.dataChannel.bufferedAmount > 1024 * 1024) {
+        await new Promise(r => setTimeout(r, 10));
+      }
+      this.dataChannel.send(chunk);
+    }
+  }
+
+  setDataChannel(dc) {
+    this.dataChannel = dc;
+  }
+
+  close() {
+    if (this.dataChannel) {
+      try { this.dataChannel.close(); } catch {}
+      this.dataChannel = null;
+    }
+  }
+}
+
+// Discovery transport — fallback to HTTP via discovery server (extension-only)
+export class DiscoveryTransport extends SyncTransportBase {
+  constructor(toHandle, fromHandle) {
+    super('discovery');
+    this.toHandle = toHandle;
+    this.fromHandle = fromHandle;
+  }
+
+  async send(envelope) {
+    const serverUrl = getPrimaryServer();
+    const res = await fetch(`${serverUrl}/messages`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        toHandle: this.toHandle,
+        fromHandle: this.fromHandle,
+        payload: envelope,
+      }),
+      signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(`Discovery server error: ${res.status} ${err.error || res.statusText}`);
+    }
+    return { received: true };
+  }
+}
+
+// Select the best available transport for a given peer
+export async function selectSyncTransport(peerPK, { peerHandle } = {}) {
+  const identity = config.get('identity');
+
+  // Try P2P transports first (LAN, then WebRTC)
+  try {
+    const best = await selectBestTransport(peerPK);
+    if (best) {
+      if (best.transport === TRANSPORT.LAN) {
+        return new LanTransport(best.address);
+      }
+      if (best.transport === TRANSPORT.P2P) {
+        return new WebRTCTransport(best.iceServers, identity?.publicKey, peerPK);
+      }
+    }
+  } catch (err) {
+    logger.debug(`P2P transport selection failed: ${err.message}`);
+  }
+
+  // Fallback to discovery server if peer has a handle
+  if (peerHandle && identity?.handle) {
+    return new DiscoveryTransport(peerHandle, identity.handle);
+  }
+
+  throw new Error('No available transport to reach peer. Ensure both peers are on the same LAN or have Pro for internet sync.');
+}
+
+// Find a peer's LAN address by public key (used for direct connection)
+export function findLanPeer(peerPK) {
+  const nearby = getNearbyPeers();
+  return nearby.find(p => p.publicKey === peerPK) || null;
+}
+
+// --- Compression helpers ---
+
+export async function compressData(data) {
+  return gzip(data);
+}
+
+export async function decompressData(data) {
+  return gunzip(data);
+}
+
+// --- Bandwidth throttle (token bucket) ---
+
+export class BandwidthThrottle {
+  constructor(kbps) {
+    this.bytesPerMs = (kbps * 1024) / 1000;
+    this.tokens = kbps * 1024; // start with 1 second of tokens
+    this.lastRefill = Date.now();
+  }
+
+  async throttle(bytes) {
+    if (this.bytesPerMs <= 0) return; // no limit
+
+    // Refill tokens
+    const now = Date.now();
+    const elapsed = now - this.lastRefill;
+    this.tokens = Math.min(this.bytesPerMs * 1000, this.tokens + elapsed * this.bytesPerMs);
+    this.lastRefill = now;
+
+    // Wait if we don't have enough tokens
+    if (this.tokens < bytes) {
+      const waitMs = Math.ceil((bytes - this.tokens) / this.bytesPerMs);
+      await new Promise(r => setTimeout(r, waitMs));
+      this.tokens = 0;
+    } else {
+      this.tokens -= bytes;
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pal-explorer-cli",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "description": "P2P encrypted file sharing CLI — share files directly with friends, not with the cloud",
   "main": "bin/pal.js",
   "bin": {