server.js

'use strict';

const express = require('express');
const { WebSocketServer } = require('ws');
const https = require('https');
const http  = require('http');
const path  = require('path');
const os    = require('os');
const fs    = require('fs');

// ── TLS certificate (auto-generated, persisted on disk) ───────────────────────
// iOS Safari requires HTTPS for getUserMedia (microphone access).

const CERT_DIR = path.join(__dirname, '.cert');
const CERT_KEY = path.join(CERT_DIR, 'key.pem');
const CERT_CRT = path.join(CERT_DIR, 'cert.pem');

let sslOptions;
if (fs.existsSync(CERT_KEY) && fs.existsSync(CERT_CRT)) {
  sslOptions = { key: fs.readFileSync(CERT_KEY), cert: fs.readFileSync(CERT_CRT) };
} else {
  const { execSync } = require('child_process');
  fs.mkdirSync(CERT_DIR, { recursive: true });
  execSync(
    `openssl req -x509 -newkey rsa:2048 -days 3650 -nodes` +
    ` -keyout "${CERT_KEY}" -out "${CERT_CRT}"` +
    ` -subj "/CN=lan-voice-chat"`,
    { stdio: 'pipe' },
  );
  sslOptions = { key: fs.readFileSync(CERT_KEY), cert: fs.readFileSync(CERT_CRT) };
  console.log('[tls] generated new self-signed certificate → .cert/');
}

// ── Servers ───────────────────────────────────────────────────────────────────

const app    = express();
const server = https.createServer(sslOptions, app);
const wss    = new WebSocketServer({ server });

// HTTP → HTTPS redirect (plain http://ip:3000 → https://ip:3000)
const httpRedirect = http.createServer((req, res) => {
  res.writeHead(301, { Location: `https://${req.headers.host}${req.url}` });
  res.end();
});

app.use(express.static(path.join(__dirname, 'public')));

// Track connected clients: id -> { ws, name, isAlive }
const clients = new Map();
let nextId = 1;

// ── Helpers ──────────────────────────────────────────────────────────────────

function broadcast(data, excludeId = null) {
  const msg = JSON.stringify(data);
  for (const [id, client] of clients) {
    if (id !== excludeId && client.ws.readyState === 1 /* OPEN */) {
      client.ws.send(msg);
    }
  }
}

function sendTo(targetId, data) {
  const client = clients.get(targetId);
  if (client && client.ws.readyState === 1) {
    client.ws.send(JSON.stringify(data));
  }
}

// ── WebSocket connection handling ─────────────────────────────────────────────

wss.on('connection', (ws) => {
  const id = nextId++;
  clients.set(id, { ws, name: `User ${id}`, isAlive: true });

  // Send assigned ID and current room state
  ws.send(JSON.stringify({
    type: 'welcome',
    id,
    peers: Array.from(clients.entries())
      .filter(([pid]) => pid !== id)
      .map(([pid, c]) => ({ id: pid, name: c.name })),
  }));

  // Notify existing peers about the newcomer
  broadcast({ type: 'peer-joined', id, name: clients.get(id).name }, id);

  ws.on('message', (raw) => {
    let msg;
    try { msg = JSON.parse(raw); } catch { return; }

    const client = clients.get(id);
    if (!client) return;

    switch (msg.type) {
      case 'pong': {
        client.isAlive = true;
        break;
      }
      case 'set-name': {
        if (typeof msg.name !== 'string') break;
        client.name = msg.name.trim().slice(0, 32) || `User ${id}`;
        broadcast({ type: 'peer-renamed', id, name: client.name }, id);
        break;
      }
      // WebRTC signaling — relay to target peer
      case 'offer':
      case 'answer':
      case 'ice-candidate': {
        if (typeof msg.target === 'number') {
          sendTo(msg.target, { ...msg, from: id });
        }
        break;
      }
    }
  });

  ws.on('close', () => {
    clients.delete(id);
    broadcast({ type: 'peer-left', id });
  });

  ws.on('error', (err) => {
    console.error(`[ws] client ${id} error:`, err.message);
    clients.delete(id);
    broadcast({ type: 'peer-left', id });
  });
});

// ── Heartbeat: ping every 25s, kill if no pong within 10s ────────────────────

const PING_INTERVAL = 25_000;
const PONG_TIMEOUT  = 10_000;

setInterval(() => {
  for (const [id, client] of clients) {
    if (!client.isAlive) {
      // No pong received since last ping — terminate
      console.log(`[heartbeat] terminating dead client ${id}`);
      client.ws.terminate();
      clients.delete(id);
      broadcast({ type: 'peer-left', id });
      continue;
    }
    client.isAlive = false;

    if (client.ws.readyState === 1) {
      client.ws.send(JSON.stringify({ type: 'ping' }));
      // Schedule pong-timeout check
      setTimeout(() => {
        const c = clients.get(id);
        if (c && !c.isAlive) {
          console.log(`[heartbeat] pong timeout for client ${id}`);
          c.ws.terminate();
          clients.delete(id);
          broadcast({ type: 'peer-left', id });
        }
      }, PONG_TIMEOUT);
    }
  }
}, PING_INTERVAL);

// ── Start servers ─────────────────────────────────────────────────────────────

const PORT      = parseInt(process.env.PORT || '3000', 10);
const HTTP_PORT = PORT + 1; // plain-HTTP redirect listener

function getLanAddresses() {
  const addrs = [];
  for (const iface of Object.values(os.networkInterfaces())) {
    for (const addr of iface) {
      if (addr.family === 'IPv4' && !addr.internal) addrs.push(addr.address);
    }
  }
  return addrs;
}

server.listen(PORT, '0.0.0.0', () => {
  const addresses = getLanAddresses();

  console.log('\nLAN Voice Chat running (HTTPS)\n');
  console.log(`  Local:   https://localhost:${PORT}`);
  for (const addr of addresses) {
    console.log(`  Network: https://${addr}:${PORT}  <-- share this`);
  }
  console.log('\n  NOTE: browsers will show a security warning for the self-signed');
  console.log('  certificate. Click "Advanced" → "Proceed" (or "Visit Website" on iOS).');
  console.log('\nPress Ctrl+C to stop.\n');
});

httpRedirect.listen(HTTP_PORT, '0.0.0.0', () => {
  console.log(`[redirect] http://…:${HTTP_PORT} → https://…:${PORT}`);
});