freertc 0.1.0

package/scripts/d1-schema.sql

@@ -0,0 +1,44 @@
+-- D1 schema for freertc signaling relay
+
+CREATE TABLE IF NOT EXISTS psp_announcements (
+  network TEXT NOT NULL,
+  peer_id TEXT NOT NULL,
+  session_id TEXT,
+  expires_at_ms INTEGER NOT NULL,
+  updated_at_ms INTEGER NOT NULL,
+  PRIMARY KEY (network, peer_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_announcements_network_expires
+  ON psp_announcements (network, expires_at_ms);
+
+CREATE TABLE IF NOT EXISTS psp_relay (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  network TEXT NOT NULL,
+  to_peer_id TEXT NOT NULL,
+  type TEXT NOT NULL,
+  session_id TEXT,
+  message_json TEXT NOT NULL,
+  expires_at_ms INTEGER NOT NULL,
+  created_at_ms INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_relay_lookup
+  ON psp_relay (network, to_peer_id, created_at_ms);
+
+CREATE INDEX IF NOT EXISTS idx_relay_lookup_ordered
+  ON psp_relay (network, to_peer_id, created_at_ms, id);
+
+CREATE INDEX IF NOT EXISTS idx_relay_expires
+  ON psp_relay (expires_at_ms);
+
+-- Federated relay registry (populated on hub workers)
+CREATE TABLE IF NOT EXISTS psp_relays (
+  url TEXT PRIMARY KEY,
+  name TEXT,
+  registered_at_ms INTEGER NOT NULL,
+  last_seen_ms INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_relays_last_seen
+  ON psp_relays (last_seen_ms);

package/scripts/dev-server.mjs

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { resolveWranglerCommand } from './project-bootstrap.mjs';
+
+const ROOT = process.cwd();
+const CARGO_BIN = path.join(os.homedir(), '.cargo', 'bin');
+const PATH_WITH_CARGO = `${CARGO_BIN}${path.delimiter}${process.env.PATH || ''}`;
+const WASM_TARGET = 'wasm32-unknown-unknown';
+
+function run(command, args, options = {}) {
+  return spawnSync(command, args, {
+    cwd: ROOT,
+    stdio: 'inherit',
+    env: { ...process.env, PATH: PATH_WITH_CARGO },
+    ...options
+  });
+}
+
+function runCapture(command, args) {
+  return spawnSync(command, args, {
+    cwd: ROOT,
+    stdio: 'pipe',
+    encoding: 'utf8',
+    env: { ...process.env, PATH: PATH_WITH_CARGO }
+  });
+}
+
+function commandExists(command, args = ['--version']) {
+  const result = spawnSync(command, args, {
+    cwd: ROOT,
+    stdio: 'ignore',
+    env: { ...process.env, PATH: PATH_WITH_CARGO }
+  });
+  return result.status === 0;
+}
+
+function fail(message) {
+  console.error(`\n[dev-setup] ${message}`);
+  process.exit(1);
+}
+
+function hasWasmTargetInstalled() {
+  const sysroot = runCapture('rustc', ['--print', 'sysroot']);
+  if (sysroot.status !== 0) return false;
+  const sysrootPath = (sysroot.stdout || '').trim();
+  if (!sysrootPath) return false;
+
+  const targetDir = path.join(sysrootPath, 'lib', 'rustlib', WASM_TARGET);
+  return fs.existsSync(targetDir);
+}
+
+function ensureWorkerBuild() {
+  if (commandExists('worker-build')) return;
+
+  if (!commandExists('cargo')) {
+    fail('Missing Cargo. Install Rust toolchain first: https://rustup.rs');
+  }
+
+  console.log('[dev-setup] Installing worker-build via Cargo...');
+  const installed = run('cargo', ['install', 'worker-build']);
+  if (installed.status !== 0) {
+    fail('Failed to install worker-build.');
+  }
+}
+
+function ensureWasmTarget() {
+  if (!commandExists('rustc')) {
+    fail('Missing Rust compiler. Install Rust toolchain first: https://rustup.rs');
+  }
+
+  if (hasWasmTargetInstalled()) return;
+
+  if (!commandExists('rustup')) {
+    fail(
+      'Missing WebAssembly Rust target, and rustup is not available to auto-install it.\n' +
+      'Install rustup, then run: rustup target add wasm32-unknown-unknown'
+    );
+  }
+
+  console.log('[dev-setup] Installing WebAssembly Rust target...');
+  const installed = run('rustup', ['target', 'add', WASM_TARGET]);
+  if (installed.status !== 0 || !hasWasmTargetInstalled()) {
+    fail('Failed to install WebAssembly Rust target.');
+  }
+}
+
+function resolveWranglerArgs() {
+  const localConfig = path.join(ROOT, 'wrangler.jsonc');
+  const workersDevConfig = path.join(ROOT, 'wrangler.workers-dev.jsonc');
+
+  if (fs.existsSync(localConfig)) {
+    return {
+      args: ['dev'],
+      configPath: localConfig
+    };
+  }
+  if (fs.existsSync(workersDevConfig)) {
+    return {
+      args: ['dev', '--config', 'wrangler.workers-dev.jsonc'],
+      configPath: workersDevConfig
+    };
+  }
+
+  fail('No Wrangler config found. Create wrangler.jsonc or keep wrangler.workers-dev.jsonc.');
+}
+
+function configUsesWorkerBuild(configPath) {
+  try {
+    const text = fs.readFileSync(configPath, 'utf8');
+    return /worker-build/.test(text);
+  } catch {
+    return false;
+  }
+}
+
+const resolved = resolveWranglerArgs();
+const wrangler = resolveWranglerCommand(ROOT);
+
+if (configUsesWorkerBuild(resolved.configPath)) {
+  ensureWorkerBuild();
+  ensureWasmTarget();
+}
+
+const started = run(wrangler.command, [...wrangler.baseArgs, ...resolved.args]);
+process.exit(started.status ?? 1);

package/scripts/non-cloudflare-server.mjs

@@ -0,0 +1,427 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { createServer } from 'node:http';
+import { fileURLToPath } from 'node:url';
+import { WebSocketServer } from 'ws';
+
+const PSP_VERSION = '1.0';
+const DEFAULT_TTL_MS = 30_000;
+const MAX_TTL_MS = 120_000;
+const MAX_MESSAGE_SIZE = 64 * 1024;
+const MAX_BATCH = 50;
+
+const DISCOVERY_TYPES = new Set(['announce', 'withdraw', 'discover', 'peer_list', 'redirect']);
+const NEGOTIATION_TYPES = new Set(['connect_request', 'connect_accept', 'connect_reject', 'offer', 'answer', 'ice_candidate', 'ice_end', 'renegotiate']);
+const CONTROL_TYPES = new Set(['ping', 'pong', 'bye', 'error', 'ack']);
+const EXTENSION_TYPES = new Set(['ext']);
+const MESSAGE_TYPES = new Set([...DISCOVERY_TYPES, ...NEGOTIATION_TYPES, ...CONTROL_TYPES, ...EXTENSION_TYPES]);
+
+const RELAY_TYPES = new Set([
+  'connect_request', 'connect_accept', 'connect_reject',
+  'offer', 'answer', 'ice_candidate', 'ice_end', 'renegotiate',
+  'bye', 'error', 'ack', 'ext', 'peer_list', 'redirect'
+]);
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const ROOT = path.resolve(__dirname, '..');
+const PUBLIC_DIR = path.join(ROOT, 'public');
+const HOST = process.env.HOST || '127.0.0.1';
+const PORT = Number(process.env.PORT || 8788);
+
+const livePeers = new Map(); // network:peerId -> { socket, peerId, network, lastSeen }
+const networkSubscribers = new Map(); // network -> Set<WebSocket>
+const announcements = new Map(); // network:peerId -> { sessionId, expiresAtMs, updatedAtMs }
+const relayQueue = new Map(); // network:toPeerId -> [{ id, message, expiresAtMs, createdAtMs }]
+
+let relayMessageId = 1;
+
+function makePeerKey(network, peerId) {
+  return `${network}:${peerId}`;
+}
+
+function normalizeTtl(ttlMs) {
+  const value = Number(ttlMs);
+  if (!Number.isFinite(value) || value <= 0) {
+    return DEFAULT_TTL_MS;
+  }
+  return Math.min(value, MAX_TTL_MS);
+}
+
+function json(res, body, status = 200) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Access-Control-Allow-Origin': '*',
+    'Content-Length': Buffer.byteLength(payload)
+  });
+  res.end(payload);
+}
+
+function validEnvelope(msg) {
+  return (
+    typeof msg === 'object' && msg !== null &&
+    msg.psp_version === PSP_VERSION &&
+    typeof msg.type === 'string' && MESSAGE_TYPES.has(msg.type) &&
+    typeof msg.from === 'string' && msg.from.trim() &&
+    typeof msg.network === 'string' && msg.network.trim() &&
+    typeof msg.message_id === 'string' &&
+    typeof msg.timestamp === 'number'
+  );
+}
+
+function cleanExpired() {
+  const now = Date.now();
+
+  for (const [key, row] of announcements.entries()) {
+    if (row.expiresAtMs <= now) {
+      announcements.delete(key);
+      livePeers.delete(key);
+    }
+  }
+
+  for (const [queueKey, entries] of relayQueue.entries()) {
+    const remaining = entries.filter((item) => item.expiresAtMs > now);
+    if (remaining.length === 0) {
+      relayQueue.delete(queueKey);
+    } else {
+      relayQueue.set(queueKey, remaining);
+    }
+  }
+}
+
+function listPeers(network, requesterPeerId = null) {
+  const now = Date.now();
+  const out = [];
+  for (const [key, row] of announcements.entries()) {
+    const [rowNetwork, rowPeerId] = key.split(':');
+    if (rowNetwork !== network || row.expiresAtMs <= now) {
+      continue;
+    }
+    if (requesterPeerId && rowPeerId === requesterPeerId) {
+      continue;
+    }
+    out.push({
+      peer_id: rowPeerId,
+      session_id: row.sessionId,
+      timestamp: row.updatedAtMs
+    });
+    if (out.length >= MAX_BATCH) {
+      break;
+    }
+  }
+  out.sort((a, b) => a.peer_id.localeCompare(b.peer_id));
+  return out;
+}
+
+function sendSafe(socket, payloadObj) {
+  try {
+    socket.send(JSON.stringify(payloadObj));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function sendPeerList(network) {
+  const sockets = networkSubscribers.get(network);
+  if (!sockets || sockets.size === 0) {
+    return;
+  }
+  const peers = listPeers(network);
+  const message = {
+    psp_version: PSP_VERSION,
+    type: 'peer_list',
+    network,
+    from: 'bootstrap-relay',
+    to: null,
+    message_id: crypto.randomUUID(),
+    timestamp: Date.now(),
+    ttl_ms: DEFAULT_TTL_MS,
+    body: { peers }
+  };
+
+  for (const socket of sockets) {
+    if (socket.readyState !== socket.OPEN) {
+      sockets.delete(socket);
+      continue;
+    }
+    sendSafe(socket, message);
+  }
+}
+
+function queueRelayMessage(message) {
+  const key = makePeerKey(message.network, message.to);
+  const now = Date.now();
+  const ttl = normalizeTtl(message.ttl_ms);
+  const list = relayQueue.get(key) || [];
+  list.push({
+    id: relayMessageId++,
+    message,
+    createdAtMs: now,
+    expiresAtMs: now + ttl
+  });
+  relayQueue.set(key, list);
+}
+
+function deliverQueued(network, peerId, socket) {
+  const key = makePeerKey(network, peerId);
+  const queue = relayQueue.get(key) || [];
+  if (queue.length === 0) {
+    return 0;
+  }
+
+  const now = Date.now();
+  const fresh = [];
+  let delivered = 0;
+  for (const item of queue) {
+    if (item.expiresAtMs <= now) {
+      continue;
+    }
+    if (delivered < MAX_BATCH && sendSafe(socket, item.message)) {
+      delivered += 1;
+    } else {
+      fresh.push(item);
+    }
+  }
+
+  if (fresh.length === 0) {
+    relayQueue.delete(key);
+  } else {
+    relayQueue.set(key, fresh);
+  }
+
+  return delivered;
+}
+
+function upsertAnnouncement(message) {
+  const key = makePeerKey(message.network, message.from);
+  const now = Date.now();
+  const ttl = normalizeTtl(message.ttl_ms);
+  announcements.set(key, {
+    sessionId: message.session_id || null,
+    expiresAtMs: now + ttl,
+    updatedAtMs: now
+  });
+}
+
+function cleanupSocketState(socket) {
+  const state = socket.__peerState;
+  if (!state?.network || !state.peerId) {
+    return;
+  }
+
+  const { network, peerId } = state;
+  const key = makePeerKey(network, peerId);
+  announcements.delete(key);
+  livePeers.delete(key);
+
+  const sockets = networkSubscribers.get(network);
+  if (sockets) {
+    sockets.delete(socket);
+    if (sockets.size === 0) {
+      networkSubscribers.delete(network);
+    }
+  }
+
+  socket.__peerState = null;
+  sendPeerList(network);
+}
+
+function subscribeSocket(socket, network) {
+  const previous = socket.__peerState?.network;
+  if (previous && previous !== network) {
+    const oldSet = networkSubscribers.get(previous);
+    if (oldSet) {
+      oldSet.delete(socket);
+      if (oldSet.size === 0) {
+        networkSubscribers.delete(previous);
+      }
+    }
+  }
+
+  if (!networkSubscribers.has(network)) {
+    networkSubscribers.set(network, new Set());
+  }
+  networkSubscribers.get(network).add(socket);
+}
+
+function attachSocketHandlers(socket) {
+  socket.__peerState = null;
+
+  socket.on('message', (raw) => {
+    cleanExpired();
+
+    const rawString = raw.toString();
+    if (!rawString || rawString.length > MAX_MESSAGE_SIZE) {
+      return;
+    }
+
+    let message;
+    try {
+      message = JSON.parse(rawString);
+    } catch {
+      sendSafe(socket, {
+        psp_version: PSP_VERSION,
+        type: 'error',
+        from: 'relay',
+        to: 'client',
+        body: { error: 'Invalid JSON' }
+      });
+      return;
+    }
+
+    if (!validEnvelope(message)) {
+      sendSafe(socket, {
+        psp_version: PSP_VERSION,
+        type: 'error',
+        from: 'relay',
+        to: message?.from || 'unknown',
+        body: { error: 'Invalid PSP envelope' }
+      });
+      return;
+    }
+
+    const { network, from: peerId, type } = message;
+    const key = makePeerKey(network, peerId);
+    const previousKey = socket.__peerState ? makePeerKey(socket.__peerState.network, socket.__peerState.peerId) : null;
+
+    subscribeSocket(socket, network);
+    socket.__peerState = { network, peerId };
+    livePeers.set(key, { socket, network, peerId, lastSeen: Date.now() });
+
+    if (type === 'announce') {
+      upsertAnnouncement(message);
+      deliverQueued(network, peerId, socket);
+
+      const isHeartbeat = previousKey === key;
+      if (!isHeartbeat) {
+        sendPeerList(network);
+      }
+      return;
+    }
+
+    if (type === 'withdraw' || type === 'bye') {
+      announcements.delete(key);
+      livePeers.delete(key);
+      sendPeerList(network);
+      return;
+    }
+
+    if (type === 'discover') {
+      sendPeerList(network);
+      return;
+    }
+
+    if (type === 'ping') {
+      sendSafe(socket, {
+        psp_version: PSP_VERSION,
+        type: 'pong',
+        network,
+        from: 'relay',
+        to: peerId,
+        message_id: crypto.randomUUID(),
+        timestamp: Date.now(),
+        ttl_ms: DEFAULT_TTL_MS,
+        body: {}
+      });
+      deliverQueued(network, peerId, socket);
+      return;
+    }
+
+    if (RELAY_TYPES.has(type) && message.to) {
+      const targetKey = makePeerKey(network, message.to);
+      const live = livePeers.get(targetKey);
+      if (live && live.socket.readyState === live.socket.OPEN && sendSafe(live.socket, message)) {
+        return;
+      }
+      queueRelayMessage(message);
+    }
+  });
+
+  socket.on('close', () => cleanupSocketState(socket));
+  socket.on('error', () => cleanupSocketState(socket));
+}
+
+function contentType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === '.html') return 'text/html; charset=utf-8';
+  if (ext === '.js') return 'application/javascript; charset=utf-8';
+  if (ext === '.css') return 'text/css; charset=utf-8';
+  if (ext === '.json') return 'application/json; charset=utf-8';
+  if (ext === '.svg') return 'image/svg+xml';
+  if (ext === '.png') return 'image/png';
+  if (ext === '.jpg' || ext === '.jpeg') return 'image/jpeg';
+  return 'application/octet-stream';
+}
+
+function serveStatic(req, res) {
+  const reqUrl = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+  let pathname = decodeURIComponent(reqUrl.pathname);
+  if (pathname === '/') {
+    pathname = '/index.html';
+  }
+
+  const requested = path.normalize(path.join(PUBLIC_DIR, pathname));
+  if (!requested.startsWith(PUBLIC_DIR)) {
+    res.writeHead(403);
+    res.end('Forbidden');
+    return;
+  }
+
+  if (!fs.existsSync(requested) || fs.statSync(requested).isDirectory()) {
+    res.writeHead(404);
+    res.end('Not Found');
+    return;
+  }
+
+  const body = fs.readFileSync(requested);
+  res.writeHead(200, { 'Content-Type': contentType(requested), 'Content-Length': body.length });
+  res.end(body);
+}
+
+const server = createServer((req, res) => {
+  cleanExpired();
+
+  const reqUrl = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+  if (reqUrl.pathname === '/health') {
+    json(res, { ok: true, version: PSP_VERSION, peers: livePeers.size }, 200);
+    return;
+  }
+
+  if (reqUrl.pathname === '/ws') {
+    json(res, { ok: false, error: 'Expected WebSocket upgrade on /ws' }, 426);
+    return;
+  }
+
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    json(res, { ok: false, error: 'Method not allowed' }, 405);
+    return;
+  }
+
+  serveStatic(req, res);
+});
+
+const wss = new WebSocketServer({ noServer: true });
+wss.on('connection', (socket) => attachSocketHandlers(socket));
+
+server.on('upgrade', (req, socket, head) => {
+  const reqUrl = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+  if (reqUrl.pathname !== '/ws') {
+    socket.destroy();
+    return;
+  }
+
+  wss.handleUpgrade(req, socket, head, (ws) => {
+    wss.emit('connection', ws, req);
+  });
+});
+
+setInterval(cleanExpired, 5000).unref();
+
+server.listen(PORT, HOST, () => {
+  console.log(`[node-relay] listening on http://${HOST}:${PORT}`);
+  console.log(`[node-relay] ws endpoint ws://${HOST}:${PORT}/ws`);
+});

package/scripts/postinstall-message.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+const isGlobalInstall = process.env.npm_config_global === 'true';
+
+const lines = [
+  '',
+  'freertc installed.',
+  'Run commands from the project directory where you want the worker files created.',
+  '',
+  'Quick start:',
+  isGlobalInstall ? '  1) freertc' : '  1) npx freertc',
+  isGlobalInstall ? '  2) freertc deploy' : '  2) npx freertc deploy',
+  '',
+  'Need full control? Use:',
+  isGlobalInstall ? '  freertc wizard' : '  npx freertc wizard',
+  ''
+];
+
+console.log(lines.join('\n'));