@jlongo78/agent-spaces 0.7.7 → 0.8.0

package/.next/standalone/bin/mdns-service.js

@@ -0,0 +1,171 @@
+/**
+ * mDNS service: advertises this Spaces node on the LAN and discovers peers.
+ * Required by terminal-server.js.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const NODE_JSON_PATH = path.join(os.homedir(), '.spaces', 'node.json');
+const NETWORK_DB_PATH = path.join(os.homedir(), '.spaces', 'network.db');
+
+function getNodeIdentity() {
+  try {
+    if (fs.existsSync(NODE_JSON_PATH)) {
+      return JSON.parse(fs.readFileSync(NODE_JSON_PATH, 'utf-8'));
+    }
+  } catch { /* ignore */ }
+
+  // Create lazily
+  const crypto = require('crypto');
+  const identity = {
+    nodeId: crypto.randomUUID(),
+    nodeName: os.hostname(),
+    createdAt: new Date().toISOString(),
+  };
+  const dir = path.dirname(NODE_JSON_PATH);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(NODE_JSON_PATH, JSON.stringify(identity, null, 2), { mode: 0o600 });
+  return identity;
+}
+
+function getVersion() {
+  try {
+    const pkgPath = path.join(__dirname, '..', 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+let _networkDbRW = null;
+
+function getNetworkDbRW() {
+  if (_networkDbRW) return _networkDbRW;
+  try {
+    const Database = require('better-sqlite3');
+    const dir = path.dirname(NETWORK_DB_PATH);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const db = new Database(NETWORK_DB_PATH);
+    db.pragma('journal_mode = WAL');
+    db.pragma('busy_timeout = 5000');
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS nodes (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        url TEXT NOT NULL,
+        api_key_encrypted TEXT NOT NULL DEFAULT '',
+        api_key_hint TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'unknown',
+        last_seen TEXT,
+        last_error TEXT,
+        session_count INTEGER DEFAULT 0,
+        version TEXT,
+        discovered_via TEXT DEFAULT 'manual',
+        created TEXT DEFAULT (datetime('now')),
+        updated TEXT DEFAULT (datetime('now'))
+      );
+    `);
+    _networkDbRW = db;
+    return db;
+  } catch (err) {
+    console.error('[mDNS] Failed to open network DB:', err.message);
+    return null;
+  }
+}
+
+function upsertDiscoveredNode(info) {
+  const db = getNetworkDbRW();
+  if (!db) return;
+  try {
+    db.prepare(`
+      INSERT INTO nodes (id, name, url, api_key_encrypted, api_key_hint, status, version, discovered_via, last_seen)
+      VALUES (?, ?, ?, '', '', 'online', ?, 'mdns', datetime('now'))
+      ON CONFLICT(id) DO UPDATE SET
+        name = excluded.name,
+        url = excluded.url,
+        version = excluded.version,
+        status = 'online',
+        last_seen = datetime('now'),
+        updated = datetime('now')
+    `).run(info.nodeId, info.nodeName, info.url, info.version);
+    console.log(`[mDNS] Discovered: ${info.nodeName} at ${info.url}`);
+  } catch (err) {
+    console.error('[mDNS] DB upsert error:', err.message);
+  }
+}
+
+function markNodeOffline(nodeId) {
+  const db = getNetworkDbRW();
+  if (!db) return;
+  try {
+    db.prepare(`
+      UPDATE nodes SET status = 'offline', updated = datetime('now')
+      WHERE id = ? AND discovered_via = 'mdns'
+    `).run(nodeId);
+  } catch { /* ignore */ }
+}
+
+function startMdns(port) {
+  let Bonjour;
+  try {
+    Bonjour = require('bonjour-service').Bonjour;
+  } catch (err) {
+    console.log('[mDNS] bonjour-service not available, skipping discovery:', err.message);
+    return;
+  }
+
+  const identity = getNodeIdentity();
+  const version = getVersion();
+  const bonjour = new Bonjour();
+
+  // Advertise this node
+  const service = bonjour.publish({
+    name: identity.nodeName,
+    type: 'spaces-agent',
+    port: port,
+    txt: {
+      nodeId: identity.nodeId,
+      version: version,
+      protocol: 'http',
+    },
+  });
+
+  console.log(`[mDNS] Advertising as "${identity.nodeName}" (${identity.nodeId.slice(0, 8)}) on port ${port}`);
+
+  // Browse for peers
+  const browser = bonjour.find({ type: 'spaces-agent' });
+
+  browser.on('up', (svc) => {
+    const remoteNodeId = svc.txt?.nodeId;
+    if (!remoteNodeId || remoteNodeId === identity.nodeId) return; // Skip self
+
+    const protocol = svc.txt?.protocol || 'http';
+    const host = svc.host || svc.referer?.address;
+    if (!host) return;
+
+    const url = `${protocol}://${host}:${svc.port}`;
+    upsertDiscoveredNode({
+      nodeId: remoteNodeId,
+      nodeName: svc.name || host,
+      url,
+      version: svc.txt?.version || '',
+    });
+  });
+
+  browser.on('down', (svc) => {
+    const remoteNodeId = svc.txt?.nodeId;
+    if (remoteNodeId && remoteNodeId !== identity.nodeId) {
+      markNodeOffline(remoteNodeId);
+      console.log(`[mDNS] Node went down: ${svc.name}`);
+    }
+  });
+
+  return { bonjour, service, browser };
+}
+
+module.exports = { startMdns };

package/.next/standalone/bin/postinstall.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+// Postinstall script for @jlongo78/agent-spaces
+//
+// 1. Rebuilds better-sqlite3 native addon for the current Node.js version
+// 2. Removes any pre-compiled native modules from the standalone bundle
+//    so they resolve from the parent node_modules/ (where they were just rebuilt)
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Step 1: Rebuild native modules for this Node version
+console.log('[postinstall] Rebuilding better-sqlite3 for Node', process.version, '...');
+try {
+  execSync('npm rebuild better-sqlite3', { stdio: 'inherit' });
+} catch (e) {
+  console.error('[postinstall] Warning: failed to rebuild better-sqlite3:', e.message);
+}
+
+// Step 2: Remove stale native binaries from standalone bundle
+// Next.js standalone mode copies native modules built on the CI Node version.
+// These will crash at runtime if the user's Node version differs.
+const standaloneModules = path.join(__dirname, '..', '.next', 'standalone', 'node_modules');
+const nativeModules = ['better-sqlite3', 'node-pty', 'bindings', 'file-uri-to-path', 'detect-libc'];
+
+for (const mod of nativeModules) {
+  const modDir = path.join(standaloneModules, mod);
+  if (fs.existsSync(modDir)) {
+    fs.rmSync(modDir, { recursive: true, force: true });
+    console.log(`[postinstall] Removed stale native module from standalone: ${mod}`);
+  }
+}
+
+console.log('[postinstall] Done.');

package/.next/standalone/bin/setup-admin.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+
+const Database = require('better-sqlite3');
+const crypto = require('crypto');
+const readline = require('readline');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const SPACES_DIR = path.join(os.homedir(), '.spaces');
+const ADMIN_DB_PATH = path.join(SPACES_DIR, 'admin.db');
+const SESSION_SECRET_PATH = path.join(SPACES_DIR, 'session_secret');
+
+function prompt(rl, question) {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+
+function promptHidden(rl, question) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    stdout.write(question);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+
+    let password = '';
+    const onData = (ch) => {
+      if (ch === '\n' || ch === '\r' || ch === '\u0004') {
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdin.removeListener('data', onData);
+        stdout.write('\n');
+        resolve(password);
+      } else if (ch === '\u0003') {
+        // Ctrl+C
+        process.exit(1);
+      } else if (ch === '\u007F' || ch === '\b') {
+        // Backspace
+        if (password.length > 0) {
+          password = password.slice(0, -1);
+          stdout.write('\b \b');
+        }
+      } else {
+        password += ch;
+        stdout.write('*');
+      }
+    };
+    stdin.on('data', onData);
+  });
+}
+
+function hashPassword(password) {
+  const salt = crypto.randomBytes(16).toString('hex');
+  const hash = crypto.scryptSync(password, salt, 64).toString('hex');
+  return `${salt}:${hash}`;
+}
+
+async function main() {
+  console.log('\n  Spaces — Admin Setup\n');
+
+  // Ensure ~/.spaces directory exists
+  if (!fs.existsSync(SPACES_DIR)) {
+    fs.mkdirSync(SPACES_DIR, { recursive: true });
+    console.log(`  Created ${SPACES_DIR}`);
+  }
+
+  // Generate session secret if missing
+  let sessionSecretHex;
+  if (fs.existsSync(SESSION_SECRET_PATH)) {
+    sessionSecretHex = fs.readFileSync(SESSION_SECRET_PATH, 'utf-8').trim();
+    console.log(`  Session secret already exists at ${SESSION_SECRET_PATH}`);
+  } else {
+    const secret = crypto.randomBytes(32);
+    sessionSecretHex = secret.toString('hex');
+    fs.writeFileSync(SESSION_SECRET_PATH, sessionSecretHex, { mode: 0o600 });
+    console.log(`  Generated session secret at ${SESSION_SECRET_PATH}`);
+  }
+
+  // Open/create admin database
+  const db = new Database(ADMIN_DB_PATH);
+  db.pragma('journal_mode = WAL');
+  db.pragma('synchronous = NORMAL');
+  db.pragma('foreign_keys = ON');
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS users (
+      id TEXT PRIMARY KEY,
+      username TEXT NOT NULL UNIQUE,
+      password_hash TEXT NOT NULL,
+      display_name TEXT NOT NULL DEFAULT '',
+      shell_user TEXT NOT NULL,
+      role TEXT NOT NULL DEFAULT 'user',
+      totp_secret TEXT,
+      totp_enabled INTEGER DEFAULT 0,
+      created TEXT DEFAULT (datetime('now'))
+    );
+  `);
+
+  console.log(`  Admin database at ${ADMIN_DB_PATH}\n`);
+
+  // Check if admin already exists
+  const existingAdmin = db.prepare("SELECT username FROM users WHERE role = 'admin' LIMIT 1").get();
+  if (existingAdmin) {
+    console.log(`  An admin user already exists: ${existingAdmin.username}`);
+    console.log(`  To create another admin, use the admin panel in the web UI.\n`);
+    db.close();
+
+    console.log('  ─────────────────────────────────────────');
+    console.log(`  SPACES_SESSION_SECRET=${sessionSecretHex}`);
+    console.log('  ─────────────────────────────────────────');
+    console.log('\n  Set this as an environment variable before starting the server.\n');
+    return;
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    const username = (await prompt(rl, '  Username: ')).trim();
+    if (!username) {
+      console.error('  Error: username cannot be empty');
+      process.exit(1);
+    }
+
+    // Check uniqueness
+    const existing = db.prepare('SELECT id FROM users WHERE username = ?').get(username);
+    if (existing) {
+      console.error(`  Error: user "${username}" already exists`);
+      process.exit(1);
+    }
+
+    rl.close();
+
+    const password = await promptHidden(null, '  Password: ');
+    if (password.length < 8) {
+      console.error('  Error: password must be at least 8 characters');
+      process.exit(1);
+    }
+
+    const confirm = await promptHidden(null, '  Confirm password: ');
+    if (password !== confirm) {
+      console.error('  Error: passwords do not match');
+      process.exit(1);
+    }
+
+    const rl2 = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    const displayName = (await prompt(rl2, `  Display name [${username}]: `)).trim() || username;
+    let shellUser = os.userInfo().username;
+    if (process.platform === 'win32' && shellUser.toUpperCase() === 'SYSTEM' && process.env.USERPROFILE) {
+      const candidate = path.basename(process.env.USERPROFILE);
+      if (/^[a-zA-Z0-9][a-zA-Z0-9 ._-]{0,63}$/.test(candidate)) {
+        shellUser = candidate;
+      }
+    }
+
+    rl2.close();
+
+    // Create admin user
+    const id = crypto.randomUUID();
+    const passwordHash = hashPassword(password);
+
+    db.prepare(`
+      INSERT INTO users (id, username, password_hash, display_name, shell_user, role)
+      VALUES (?, ?, ?, ?, ?, 'admin')
+    `).run(id, username, passwordHash, displayName, shellUser);
+
+    console.log(`\n  Admin user "${username}" created successfully.`);
+    console.log(`  Shell user: ${shellUser}`);
+
+  } catch (err) {
+    console.error(`\n  Error: ${err.message}`);
+    process.exit(1);
+  } finally {
+    db.close();
+  }
+
+  console.log('\n  ─────────────────────────────────────────');
+  console.log(`  SPACES_SESSION_SECRET=${sessionSecretHex}`);
+  console.log('  ─────────────────────────────────────────');
+  console.log('\n  Set this as an environment variable before starting the server.');
+  console.log('  Example: export SPACES_SESSION_SECRET=' + sessionSecretHex);
+  console.log('  Or add it to your docker-compose.yml environment section.\n');
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/.next/standalone/bin/spaces-dev.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+
+const http = require('http');
+const fs = require('fs');
+const { spawn } = require('child_process');
+const path = require('path');
+const os = require('os');
+const SPACES_DIR = path.join(os.homedir(), '.spaces');
+const CONFIG_PATH = path.join(SPACES_DIR, 'server.json');
+const SESSION_SECRET_PATH = path.join(SPACES_DIR, 'session_secret');
+
+// ─── Load saved config ────────────────────────────────────
+let savedConfig = {};
+if (fs.existsSync(CONFIG_PATH)) {
+  try { savedConfig = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8')); } catch {}
+}
+
+// ─── Resolve settings (env > config > defaults) ──────────
+const NEXT_INTERNAL_PORT = parseInt(process.env.SPACES_NEXT_PORT || '3400', 10);
+const PORT = parseInt(process.env.SPACES_PORT || '', 10) || savedConfig.port || 3457;
+
+const basePath = process.env.SPACES_BASE_PATH || savedConfig.basePath || '';
+if (basePath) {
+  process.env.SPACES_BASE_PATH = basePath;
+}
+
+const allowedOrigins = process.env.SPACES_ALLOWED_ORIGINS || savedConfig.allowedOrigins || '';
+if (allowedOrigins) {
+  process.env.SPACES_ALLOWED_ORIGINS = allowedOrigins;
+}
+
+// ─── Managed packages directory ──────────────────────────────
+const MANAGED_PACKAGES = path.join(SPACES_DIR, 'packages');
+const MANAGED_NODE_MODULES = path.join(MANAGED_PACKAGES, 'node_modules');
+
+// ─── Auto-detect tier (check managed packages first) ─────────
+function hasManagedPro() {
+  return fs.existsSync(path.join(MANAGED_NODE_MODULES, '@spaces', 'pro', 'dist', 'index.js'));
+}
+function hasManagedTeams() {
+  return fs.existsSync(path.join(MANAGED_NODE_MODULES, '@spaces', 'teams', 'index.js'));
+}
+function hasRequirePro() {
+  try { require.resolve('@spaces/pro'); return true; } catch { return false; }
+}
+function hasRequireTeams() {
+  try { require.resolve('@spaces/teams'); return true; } catch { return false; }
+}
+
+const hasSpacesPro = hasManagedPro() || hasRequirePro();
+const hasSpacesTeams = hasManagedTeams() || hasRequireTeams();
+
+let tier = process.env.SPACES_TIER || savedConfig.tier || '';
+if (!tier) {
+  if (hasSpacesPro) tier = 'federation';
+  else if (hasSpacesTeams) tier = 'team';
+  else tier = 'community';
+}
+process.env.SPACES_TIER = tier;
+
+// ─── Resolve NODE_PATH for managed packages ──────────────────
+const nodePaths = [MANAGED_NODE_MODULES];
+// Add each managed package's own node_modules for bundled deps
+for (const pkgName of ['pro', 'teams']) {
+  const pkgDir = path.join(MANAGED_PACKAGES, pkgName, 'node_modules');
+  if (fs.existsSync(pkgDir)) nodePaths.push(pkgDir);
+}
+for (const dir of nodePaths) {
+  const existing = process.env.NODE_PATH || '';
+  if (!existing.includes(dir)) {
+    process.env.NODE_PATH = existing ? `${dir}${path.delimiter}${existing}` : dir;
+  }
+}
+require('module').Module._initPaths();
+
+// Require terminal-server AFTER tier is set so it reads the correct SPACES_TIER
+const { createTerminalServer } = require('./terminal-server');
+
+// ─── Federation prerequisites — auto-setup if needed ──────
+if (tier !== 'community') {
+  let sessionSecret = process.env.SPACES_SESSION_SECRET || '';
+  if (!sessionSecret && fs.existsSync(SESSION_SECRET_PATH)) {
+    sessionSecret = fs.readFileSync(SESSION_SECRET_PATH, 'utf-8').trim();
+  }
+
+  const adminDbPath = path.join(SPACES_DIR, 'admin.db');
+  if (!fs.existsSync(adminDbPath) || !sessionSecret) {
+    const { autoSetup } = require('./lib/auto-setup');
+    const result = autoSetup({ SPACES_DIR, SESSION_SECRET_PATH, ADMIN_DB_PATH: adminDbPath, CONFIG_PATH, tier, port: PORT, basePath });
+    sessionSecret = result.sessionSecret;
+  }
+
+  process.env.SPACES_SESSION_SECRET = sessionSecret;
+}
+
+// Spawn Next.js dev server on an internal port
+const childEnv = { ...process.env, PORT: String(NEXT_INTERNAL_PORT) };
+const next = spawn('npx', ['next', 'dev', '--hostname', '0.0.0.0', '--port', String(NEXT_INTERNAL_PORT)], {
+  cwd: path.join(__dirname, '..'),
+  stdio: ['ignore', 'pipe', 'pipe'],
+  env: childEnv,
+  shell: true,
+});
+
+let nextReady = false;
+
+next.stdout.on('data', (data) => {
+  const msg = data.toString();
+  process.stdout.write(msg);
+  if (msg.includes('Ready') || msg.includes('started server') || msg.includes('Listening') || msg.includes('localhost')) {
+    nextReady = true;
+  }
+});
+
+next.stderr.on('data', (data) => {
+  process.stderr.write(data);
+});
+
+next.on('exit', (code) => {
+  console.error(`[spaces-dev] Next.js exited with code ${code}`);
+  process.exit(code || 1);
+});
+
+// Create unified HTTP server
+const server = http.createServer((req, res) => {
+  const proxyReq = http.request(
+    {
+      hostname: '127.0.0.1',
+      port: NEXT_INTERNAL_PORT,
+      path: req.url,
+      method: req.method,
+      headers: req.headers,
+    },
+    (proxyRes) => {
+      res.writeHead(proxyRes.statusCode, proxyRes.headers);
+      proxyRes.pipe(res);
+    }
+  );
+  proxyReq.on('error', (err) => {
+    // Next.js not ready yet
+    if (!res.headersSent) {
+      res.writeHead(502);
+      res.end('Next.js dev server not ready yet. Refresh in a moment.');
+    }
+  });
+  req.pipe(proxyReq);
+});
+
+// Attach terminal WebSocket server for /ws upgrades
+createTerminalServer(server);
+
+// Proxy non-/ws upgrades (Next.js HMR WebSocket) to Next.js dev
+server.on('upgrade', (req, socket, head) => {
+  const url = new URL(req.url, 'http://localhost');
+  if (url.pathname !== '/ws' && !url.pathname.endsWith('/ws')) {
+    const proxyReq = http.request({
+      hostname: '127.0.0.1',
+      port: NEXT_INTERNAL_PORT,
+      path: req.url,
+      method: req.method,
+      headers: req.headers,
+    });
+    proxyReq.on('upgrade', (proxyRes, proxySocket, proxyHead) => {
+      socket.write(
+        'HTTP/1.1 101 Switching Protocols\r\n' +
+        Object.entries(proxyRes.headers).map(([k, v]) => `${k}: ${v}`).join('\r\n') +
+        '\r\n\r\n'
+      );
+      if (proxyHead.length > 0) proxySocket.unshift(proxyHead);
+      proxySocket.on('error', () => socket.destroy());
+      socket.on('error', () => proxySocket.destroy());
+      proxySocket.on('close', () => {
+        console.log(`[HMR proxy] upstream closed (${url.pathname})`);
+      });
+      socket.on('close', () => {
+        console.log(`[HMR proxy] browser closed (${url.pathname})`);
+      });
+      proxySocket.pipe(socket);
+      socket.pipe(proxySocket);
+    });
+    proxyReq.on('response', (res) => {
+      // Upgrade was rejected — log and clean up
+      console.log(`[HMR proxy] upgrade rejected: ${res.statusCode} for ${url.pathname}`);
+      socket.destroy();
+    });
+    proxyReq.on('error', (err) => {
+      console.log(`[HMR proxy] error: ${err.message}`);
+      socket.destroy();
+    });
+    socket.on('error', () => {});
+    if (head.length > 0) proxyReq.write(head);
+    proxyReq.end();
+  }
+});
+
+server.listen(PORT, () => {
+  console.log(`\n  Spaces dev server on http://localhost:${PORT}\n`);
+});
+
+// ─── HTTPS server for WebXR (Quest requires secure context) ──
+const HTTPS_PORT = parseInt(process.env.SPACES_HTTPS_PORT || '', 10) || PORT + 1;
+const certsDir = path.join(__dirname, '..', 'certs');
+if (fs.existsSync(path.join(certsDir, 'cert.crt')) && fs.existsSync(path.join(certsDir, 'cert.key'))) {
+  const https = require('https');
+  const httpsOptions = {
+    key: fs.readFileSync(path.join(certsDir, 'cert.key')),
+    cert: fs.readFileSync(path.join(certsDir, 'cert.crt')),
+  };
+  const httpsServer = https.createServer(httpsOptions, (req, res) => {
+    const proxyReq = http.request(
+      { hostname: '127.0.0.1', port: NEXT_INTERNAL_PORT, path: req.url, method: req.method, headers: req.headers },
+      (proxyRes) => { res.writeHead(proxyRes.statusCode, proxyRes.headers); proxyRes.pipe(res); }
+    );
+    proxyReq.on('error', () => { if (!res.headersSent) { res.writeHead(502); res.end('Not ready'); } });
+    req.pipe(proxyReq);
+  });
+  createTerminalServer(httpsServer);
+  httpsServer.on('upgrade', (req, socket, head) => {
+    const url = new URL(req.url, 'https://localhost');
+    if (url.pathname !== '/ws' && !url.pathname.endsWith('/ws')) {
+      const proxyReq = http.request({ hostname: '127.0.0.1', port: NEXT_INTERNAL_PORT, path: req.url, method: req.method, headers: req.headers });
+      proxyReq.on('upgrade', (proxyRes, proxySocket, proxyHead) => {
+        socket.write('HTTP/1.1 101 Switching Protocols\r\n' + Object.entries(proxyRes.headers).map(([k, v]) => `${k}: ${v}`).join('\r\n') + '\r\n\r\n');
+        if (proxyHead.length > 0) proxySocket.unshift(proxyHead);
+        proxySocket.pipe(socket); socket.pipe(proxySocket);
+        proxySocket.on('error', () => socket.destroy()); socket.on('error', () => proxySocket.destroy());
+      });
+      proxyReq.on('error', () => socket.destroy());
+      socket.on('error', () => {});
+      if (head.length > 0) proxyReq.write(head);
+      proxyReq.end();
+    }
+  });
+  httpsServer.listen(HTTPS_PORT, () => {
+    console.log(`  Spaces HTTPS (VR) on https://192.168.1.16:${HTTPS_PORT}/vr\n`);
+  });
+}
+
+// Cleanup
+function cleanup() {
+  next.kill();
+  server.close();
+  process.exit(0);
+}
+
+process.on('SIGINT', cleanup);
+process.on('SIGTERM', cleanup);