@walkhi/code-relax 0.1.0-beta.26 → 0.1.0-beta.28

package/dist/src/self-relay/p2p-probe.mjs

@@ -1,123 +1,152 @@
-import { randomUUID } from 'node:crypto';
-import P2pDiagnostics from '../../shared/p2p-diagnostics.cjs';
-import P2pDataFramer from '../../shared/p2p-data-channel.cjs';
-
-const PROBE_UDP_PORT_RANGE = Object.freeze({ begin: 42000, end: 42031 });
-const HIGH_WATER = 1024 * 1024;
-const LOW_WATER = 512 * 1024;
-const MAX_QUEUED = 16 * 1024 * 1024;
-
-export async function createP2pProbe({ signal, report = () => {}, onData = () => {}, iceServers = [] }) {
-  if (!validProbeIceServers(iceServers)) throw new Error('Invalid probe STUN configuration');
-  const { default: rtc } = await import('node-datachannel');
-  const peer = new rtc.PeerConnection('code-relax-probe', {
-    iceServers,
-    maxMessageSize: 65536,
-    portRangeBegin: PROBE_UDP_PORT_RANGE.begin,
-    portRangeEnd: PROBE_UDP_PORT_RANGE.end
-  });
-  const diagnostic = new P2pDiagnostics();
-  const framer = new P2pDataFramer();
-  const dataPrefix = randomUUID().replaceAll('-', '');
-  let channel, closed = false, answered = false, candidates = [], verified = false, remoteDirect = false;
-  let pingReceived = false, pongReceived = false, dataSerial = 0, queuedBytes = 0;
-  const outbound = [];
-  const nonce = randomUUID();
-  const timer = setTimeout(() => finish(verified ? 'closed' : 'timeout'), 15000);
-  function finish(state) {
-    if (closed) return;
-    closed = true; clearTimeout(timer); candidates = []; queuedBytes = 0; outbound.length = 0; framer.reset();
-    const summary = diagnostic.snapshot(state);
-    channel?.close(); peer.close(); report(state, summary);
-  }
-  function verify() {
-    if (verified || !pingReceived || !pongReceived) return;
-    verified = true; clearTimeout(timer);
-    report(remoteDirect ? 'direct' : 'verified', diagnostic.snapshot('verified'));
-    pump();
-  }
-  function pump() {
-    if (!verified || !remoteDirect || closed || !channel?.isOpen()) return;
-    try {
-      while (outbound.length && channel.bufferedAmount() < HIGH_WATER) {
-        const item = outbound[0], frame = framer.frame(item);
-        if (!channel.sendMessage(frame)) return;
-        if (framer.commit(item)) { outbound.shift(); queuedBytes -= item.bytes; }
-      }
-    } catch { diagnostic.error = 'channel'; finish('failed'); }
-  }
-  function sendData(payload) {
-    if (!verified || !remoteDirect || closed || !channel?.isOpen()) return false;
-    let item;
-    try { item = framer.create(payload, `${dataPrefix}-${++dataSerial}`); }
-    catch { return false; }
-    if (queuedBytes + item.bytes > MAX_QUEUED) return false;
-    outbound.push(item); queuedBytes += item.bytes; pump(); return true;
-  }
-  peer.onIceStateChange(state => { if (!closed) diagnostic.ice = state; });
-  peer.onGatheringStateChange(state => { if (!closed) diagnostic.gathering = state; });
-  peer.onStateChange(state => { if (!closed && (state === 'failed' || state === 'closed')) { diagnostic.error = 'peer'; finish('failed'); } });
-  peer.onLocalDescription((sdp, type) => { if (!closed) { diagnostic.offer = type === 'offer'; signal({ kind: type, sdp, iceServers, direct: 1 }); } });
-  peer.onLocalCandidate((candidate, mid) => { if (!closed) { diagnostic.candidate('local', candidate); signal({ kind: 'candidate', candidate, mid }); } });
-  channel = peer.createDataChannel('code-relax-probe-v1');
-  channel.setBufferedAmountLowThreshold(LOW_WATER);
-  channel.onBufferedAmountLow(pump);
-  channel.onOpen(() => { if (!closed) { diagnostic.open = true; channel.sendMessage(JSON.stringify({ type: 'ping', nonce })); } });
-  channel.onError(() => { if (!closed) diagnostic.error = 'channel'; finish('failed'); });
-  channel.onClosed(() => finish('closed'));
-  channel.onMessage(value => {
-    try {
-      if (closed || typeof value !== 'string' || value.length > 65536) throw new Error('Invalid P2P frame');
-      const message = JSON.parse(value);
-      const data = framer.accept(message);
-      if (data.handled) {
-        if (!verified || !remoteDirect) throw new Error('P2P transport not verified');
-        if (data.complete) onData(data.payload);
-        return;
-      }
-      if (message.type === 'ping' && /^[\w-]{16,128}$/.test(message.nonce)) {
-        diagnostic.ping = true; pingReceived = true;
-        channel.sendMessage(JSON.stringify({ type: 'pong', nonce: message.nonce }));
-      } else if (message.type === 'pong' && message.nonce === nonce) {
-        diagnostic.pong = true; pongReceived = true;
-      } else throw new Error('Invalid P2P response');
-      verify();
-    } catch { diagnostic.error = 'frame'; finish('failed'); }
-  });
-  return {
-    receive(message) {
-      if (closed) return;
-      if (message.kind === 'answer' && !answered) {
-        try { peer.setRemoteDescription(message.sdp, 'answer'); }
-        catch { diagnostic.error = 'description'; finish('failed'); return; }
-        answered = true; remoteDirect = message.direct === 1; diagnostic.answer = true;
-        for (const item of candidates) peer.addRemoteCandidate(item.candidate, item.mid);
-        candidates = [];
-      } else if (message.kind === 'candidate') {
-        diagnostic.candidate('remote', message.candidate);
-        if (answered) peer.addRemoteCandidate(message.candidate, message.mid);
-        else if (candidates.length < 64) candidates.push(message);
-        else finish('failed');
-      } else if (message.kind === 'close') finish('closed');
-      else finish('failed');
-    },
-    send: sendData,
-    close() { finish('closed'); }
-  };
-}
-
-export function validProbeSignal(value) {
-  if (!value || value.version !== 1 || !/^[\w-]{16,128}$/.test(value.probeId || '')) return false;
-  if (['start', 'close'].includes(value.kind)) return true;
-  if (['offer', 'answer'].includes(value.kind)) return typeof value.sdp === 'string' && value.sdp.length <= 65536 &&
-    (value.direct === undefined || value.direct === 0 || value.direct === 1) &&
-    (value.iceServers === undefined || validProbeIceServers(value.iceServers));
-  if (value.kind === 'candidate') return typeof value.candidate === 'string' && value.candidate.length <= 2048 &&
-    typeof value.mid === 'string' && value.mid.length <= 64;
-  return false;
-}
-
-export function validProbeIceServers(value) {
-  return Array.isArray(value) && value.length <= 4 && value.every(item =>
-    typeof item === 'string' && /^stun:[a-zA-Z0-9.-]+:[0-9]{1,5}$/.test(item) && Number(item.split(':').at(-1)) <= 65535);
-}
+import { randomUUID } from 'node:crypto';
+import P2pDiagnostics from '../../shared/p2p-diagnostics.cjs';
+import P2pDataFramer from '../../shared/p2p-data-channel.cjs';
+import FileChannel from '../../shared/p2p-file-channel.cjs';
+
+const PROBE_UDP_PORT_RANGE = Object.freeze({ begin: 42000, end: 42031 });
+const HIGH_WATER = 1024 * 1024;
+const LOW_WATER = 512 * 1024;
+const MAX_QUEUED = 16 * 1024 * 1024;
+
+export async function createP2pProbe({ signal, report = () => {}, onData = () => {}, onFileChannel, iceServers = [] }) {
+  if (!validProbeIceServers(iceServers)) throw new Error('Invalid probe STUN configuration');
+  const { default: rtc } = await import('node-datachannel');
+  const peer = new rtc.PeerConnection('code-relax-probe', {
+    iceServers,
+    maxMessageSize: 65536,
+    portRangeBegin: PROBE_UDP_PORT_RANGE.begin,
+    portRangeEnd: PROBE_UDP_PORT_RANGE.end
+  });
+  const diagnostic = new P2pDiagnostics();
+  const framer = new P2pDataFramer();
+  const dataPrefix = randomUUID().replaceAll('-', '');
+  let channel, closed = false, answered = false, candidates = [], verified = false, remoteDirect = false;
+  let pingReceived = false, pongReceived = false, dataSerial = 0, queuedBytes = 0;
+  const outbound = [];
+  const files = new Map();
+  const nonce = randomUUID();
+  const timer = setTimeout(() => finish(verified ? 'closed' : 'timeout'), 15000);
+  function finish(state) {
+    if (closed) return;
+    closed = true; clearTimeout(timer); candidates = []; queuedBytes = 0; outbound.length = 0; framer.reset();
+    for (const socket of files.values()) socket.close(1011);
+    files.clear();
+    const summary = diagnostic.snapshot(state);
+    channel?.close(); peer.close(); report(state, summary);
+  }
+  function verify() {
+    if (verified || !pingReceived || !pongReceived) return;
+    verified = true; clearTimeout(timer);
+    report(remoteDirect ? 'direct' : 'verified', diagnostic.snapshot('verified'));
+    pump();
+    for (const raw of files.keys()) activateFile(raw);
+  }
+  function activateFile(raw) {
+    const socket = files.get(raw);
+    if (!socket || socket.readyState !== 0 || !raw.isOpen() || !verified || !remoteDirect || closed) return;
+    socket.opened();
+    raw.sendMessage('{"type":"rtc-file-ready"}');
+  }
+  peer.onDataChannel(raw => {
+    if (closed || !onFileChannel || raw.getLabel() !== 'code-relax-file-v1' || files.size >= 4) { raw.close(); return; }
+    const socket = new FileChannel({ buffered: () => raw.bufferedAmount(),
+      send: value => typeof value === 'string' ? raw.sendMessage(value) : raw.sendMessageBinary(value), close: () => raw.close() });
+    files.set(raw, socket);
+    socket.addEventListener('close', () => files.delete(raw));
+    try { onFileChannel(socket); }
+    catch { socket.close(1011); return; }
+    raw.setBufferedAmountLowThreshold(128 * 1024);
+    raw.onBufferedAmountLow(() => socket.pump());
+    raw.onOpen(() => activateFile(raw));
+    raw.onClosed(() => socket.close(1011)); raw.onError(() => socket.close(1011));
+    raw.onMessage(value => {
+      if (!verified || !remoteDirect || closed || socket.readyState !== 1) { socket.close(1008); return; }
+      socket.receive(value);
+    });
+    activateFile(raw);
+  });
+  function pump() {
+    if (!verified || !remoteDirect || closed || !channel?.isOpen()) return;
+    try {
+      while (outbound.length && channel.bufferedAmount() < HIGH_WATER) {
+        const item = outbound[0], frame = framer.frame(item);
+        if (!channel.sendMessage(frame)) return;
+        if (framer.commit(item)) { outbound.shift(); queuedBytes -= item.bytes; }
+      }
+    } catch { diagnostic.error = 'channel'; finish('failed'); }
+  }
+  function sendData(payload) {
+    if (!verified || !remoteDirect || closed || !channel?.isOpen()) return false;
+    let item;
+    try { item = framer.create(payload, `${dataPrefix}-${++dataSerial}`); }
+    catch { return false; }
+    if (queuedBytes + item.bytes > MAX_QUEUED) return false;
+    outbound.push(item); queuedBytes += item.bytes; pump(); return true;
+  }
+  peer.onIceStateChange(state => { if (!closed) diagnostic.ice = state; });
+  peer.onGatheringStateChange(state => { if (!closed) diagnostic.gathering = state; });
+  peer.onStateChange(state => { if (!closed && (state === 'failed' || state === 'closed')) { diagnostic.error = 'peer'; finish('failed'); } });
+  peer.onLocalDescription((sdp, type) => { if (!closed) { diagnostic.offer = type === 'offer'; signal({ kind: type, sdp, iceServers, direct: 1 }); } });
+  peer.onLocalCandidate((candidate, mid) => { if (!closed) { diagnostic.candidate('local', candidate); signal({ kind: 'candidate', candidate, mid }); } });
+  channel = peer.createDataChannel('code-relax-probe-v1');
+  channel.setBufferedAmountLowThreshold(LOW_WATER);
+  channel.onBufferedAmountLow(pump);
+  channel.onOpen(() => { if (!closed) { diagnostic.open = true; channel.sendMessage(JSON.stringify({ type: 'ping', nonce })); } });
+  channel.onError(() => { if (!closed) diagnostic.error = 'channel'; finish('failed'); });
+  channel.onClosed(() => finish('closed'));
+  channel.onMessage(value => {
+    try {
+      if (closed || typeof value !== 'string' || value.length > 65536) throw new Error('Invalid P2P frame');
+      const message = JSON.parse(value);
+      const data = framer.accept(message);
+      if (data.handled) {
+        if (!verified || !remoteDirect) throw new Error('P2P transport not verified');
+        if (data.complete) onData(data.payload);
+        return;
+      }
+      if (message.type === 'ping' && /^[\w-]{16,128}$/.test(message.nonce)) {
+        diagnostic.ping = true; pingReceived = true;
+        channel.sendMessage(JSON.stringify({ type: 'pong', nonce: message.nonce }));
+      } else if (message.type === 'pong' && message.nonce === nonce) {
+        diagnostic.pong = true; pongReceived = true;
+      } else throw new Error('Invalid P2P response');
+      verify();
+    } catch { diagnostic.error = 'frame'; finish('failed'); }
+  });
+  return {
+    receive(message) {
+      if (closed) return;
+      if (message.kind === 'answer' && !answered) {
+        try { peer.setRemoteDescription(message.sdp, 'answer'); }
+        catch { diagnostic.error = 'description'; finish('failed'); return; }
+        answered = true; remoteDirect = message.direct === 1; diagnostic.answer = true;
+        for (const item of candidates) peer.addRemoteCandidate(item.candidate, item.mid);
+        candidates = [];
+      } else if (message.kind === 'candidate') {
+        diagnostic.candidate('remote', message.candidate);
+        if (answered) peer.addRemoteCandidate(message.candidate, message.mid);
+        else if (candidates.length < 64) candidates.push(message);
+        else finish('failed');
+      } else if (message.kind === 'close') finish('closed');
+      else finish('failed');
+    },
+    send: sendData,
+    close() { finish('closed'); }
+  };
+}
+
+export function validProbeSignal(value) {
+  if (!value || value.version !== 1 || !/^[\w-]{16,128}$/.test(value.probeId || '')) return false;
+  if (['start', 'close'].includes(value.kind)) return true;
+  if (['offer', 'answer'].includes(value.kind)) return typeof value.sdp === 'string' && value.sdp.length <= 65536 &&
+    (value.direct === undefined || value.direct === 0 || value.direct === 1) &&
+    (value.iceServers === undefined || validProbeIceServers(value.iceServers));
+  if (value.kind === 'candidate') return typeof value.candidate === 'string' && value.candidate.length <= 2048 &&
+    typeof value.mid === 'string' && value.mid.length <= 64;
+  return false;
+}
+
+export function validProbeIceServers(value) {
+  return Array.isArray(value) && value.length <= 4 && value.every(item =>
+    typeof item === 'string' && /^stun:[a-zA-Z0-9.-]+:[0-9]{1,5}$/.test(item) && Number(item.split(':').at(-1)) <= 65535);
+}

package/dist/src/self-relay/rtc-file-bridge.mjs

@@ -0,0 +1,41 @@
+import WebSocket from 'ws';
+import { loopbackUrl } from './wire.mjs';
+
+// The RTC peer belongs to an authenticated relay chat session. Its teardown
+// closes this channel on logout, expiry, revocation or signaling disconnect.
+export function attachRtcFile(channel, connection, authorized) {
+  let local, authenticated = false;
+  const timer = setTimeout(() => channel.close(1008), 5000);
+  channel.addEventListener('close', () => { clearTimeout(timer); local?.terminate(); });
+  channel.onmessage = event => {
+    try {
+      if (!authorized()) throw new Error('File authorization expired');
+      if (!local) {
+        if (typeof event.data !== 'string') throw new Error('File authentication required');
+        const auth = JSON.parse(event.data);
+        if (auth.type !== 'auth' || !['upload', 'download'].includes(auth.purpose)) throw new Error('Invalid file purpose');
+        const url = new URL(connection.url); url.pathname = '/api/file-transfer';
+        loopbackUrl(url.href, '/api/file-transfer');
+        local = new WebSocket(url.href, { maxPayload: 512 * 1024, perMessageDeflate: false });
+        local.on('open', () => {
+          if (!authorized() || channel.readyState !== 1) { local.terminate(); return; }
+          local.send(JSON.stringify({ type: 'auth', token: connection.token, purpose: auth.purpose }));
+        });
+        local.on('message', (bytes, binary) => {
+          if (!authorized() || channel.readyState !== 1) { channel.close(4401); return; }
+          try {
+            if (!authenticated) {
+              if (binary || JSON.parse(bytes.toString()).type !== 'ready') throw new Error('File authentication failed');
+              authenticated = true; clearTimeout(timer);
+            }
+            channel.send(binary ? bytes : bytes.toString());
+          } catch { channel.close(1011); }
+        });
+        local.on('close', () => channel.close(1011)); local.on('error', () => channel.close(1011));
+        return;
+      }
+      if (!authenticated || local.readyState !== WebSocket.OPEN || local.bufferedAmount > 1024 * 1024) throw new Error('File channel unavailable');
+      local.send(typeof event.data === 'string' ? event.data : Buffer.from(event.data));
+    } catch { channel.close(1008); }
+  };
+}