accelr8 3.8.2 → 4.0.0-next.1

package/dist/chunks/livekit-window-XVOCBQOM.js

@@ -0,0 +1,626 @@
+#!/usr/bin/env node
+import {
+  VOICE_PAGE_CSS,
+  VOICE_PAGE_JS,
+  voicePageCsp,
+  voicePageHtml
+} from "./chunk-EQPM4FIJ.js";
+import {
+  VoiceStore,
+  initialVoiceState,
+  isVoiceUrl,
+  normalizeVoiceState
+} from "./chunk-CAQJPW54.js";
+import {
+  accelr8Dir
+} from "./chunk-62O2F73J.js";
+
+// src/livekit-window.ts
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import fs2 from "node:fs";
+import http from "node:http";
+import os2 from "node:os";
+import path2 from "node:path";
+import { pathToFileURL } from "node:url";
+
+// src/livekit-open.ts
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var WINDOW = "--window-size=440,600";
+var LINUX_APPS = ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "microsoft-edge", "brave-browser"];
+function isVoicePageHost(hostname) {
+  return hostname === "127.0.0.1" || /^a8-[0-9a-f]{8,64}\.localhost$/.test(hostname);
+}
+function assertLocalPageUrl(url) {
+  const u = new URL(url);
+  if (u.protocol === "file:" && u.pathname.endsWith("/voice.html")) return u;
+  if (u.protocol !== "http:" || !isVoicePageHost(u.hostname)) {
+    throw new Error("the voice window only opens the local voice page");
+  }
+  return u;
+}
+function findBrowsers(platform = process.platform, env = process.env, exists = fs.existsSync) {
+  if (platform === "darwin") {
+    const names = ["Google Chrome.app", "Chromium.app", "Microsoft Edge.app", "Brave Browser.app"];
+    for (const dir of ["/Applications", path.join(env.HOME || os.homedir(), "Applications")]) {
+      for (const n of names) {
+        const p = path.join(dir, n);
+        if (exists(p)) return { macApp: p };
+      }
+    }
+    return { macApp: null };
+  }
+  if (platform === "win32") {
+    const roots = [env.ProgramFiles, env["ProgramFiles(x86)"], env.LOCALAPPDATA].filter(Boolean);
+    const rel = [["Google", "Chrome", "Application", "chrome.exe"], ["Microsoft", "Edge", "Application", "msedge.exe"]];
+    for (const r of rel) for (const root of roots) {
+      const p = path.win32.join(root, ...r);
+      if (exists(p)) return { winExe: p };
+    }
+    return { winExe: null };
+  }
+  const dirs = (env.PATH ?? "").split(":").filter(Boolean);
+  const snap = LINUX_APPS.filter((bin) => {
+    const dir = dirs.find((d) => exists(path.posix.join(d, bin)));
+    return !!dir && /(^|\/)snap\/bin\/?$/.test(dir);
+  });
+  return { snap };
+}
+function openCommands(target, platform, found, app = true) {
+  const t = typeof target === "string" ? { app: target, browser: target } : target;
+  const out = [];
+  if (platform === "darwin") {
+    if (app && found.macApp) out.push({ method: "app-window", command: "open", args: ["-na", found.macApp, "--args", `--app=${t.app}`, WINDOW] });
+    out.push({ method: "default-browser", command: "open", args: [t.browser] });
+  } else if (platform === "win32") {
+    if (app && found.winExe) out.push({ method: "app-window", command: found.winExe, args: [`--app=${t.app}`, WINDOW] });
+    out.push({ method: "default-browser", command: "rundll32", args: ["url.dll,FileProtocolHandler", t.browser] });
+  } else {
+    if (app) {
+      for (const bin of LINUX_APPS) {
+        out.push({ method: "app-window", command: bin, args: [`--app=${found.snap?.includes(bin) ? t.browser : t.app}`, WINDOW] });
+      }
+    }
+    out.push({ method: "default-browser", command: "xdg-open", args: [t.browser] });
+  }
+  return out;
+}
+var runDetached = (command, args) => new Promise((resolve) => {
+  let child;
+  try {
+    child = spawn(command, args, { stdio: "ignore", detached: true, windowsHide: true });
+  } catch {
+    resolve(false);
+    return;
+  }
+  child.once("error", () => resolve(false));
+  child.once("spawn", () => {
+    child.unref();
+    resolve(true);
+  });
+});
+async function openVoicePage(target, opts = {}) {
+  const t = typeof target === "string" ? { app: target, browser: target } : target;
+  const appUrl = assertLocalPageUrl(t.app);
+  const page = assertLocalPageUrl(t.browser);
+  if (page.protocol !== "http:") throw new Error("the default browser opens the voice page itself");
+  const platform = opts.platform ?? process.platform;
+  const run = opts.run ?? runDetached;
+  for (const a of openCommands({ app: appUrl.toString(), browser: page.toString() }, platform, opts.found ?? findBrowsers(platform), opts.app ?? true)) {
+    if (await run(a.command, a.args)) return { method: a.method };
+  }
+  throw new Error(`could not open a browser for voice \xB7 open ${page.origin}${page.pathname} yourself`);
+}
+
+// src/livekit-window.ts
+var VOICE_PORTS = [38490, 38491, 38492, 38493, 38494];
+var MAX_BODY = 64 * 1024;
+var COOKIE = "a8voice";
+var LABEL_RE = /^a8-[0-9a-f]{24}$/;
+function voiceHostLabel(dir = accelr8Dir()) {
+  const file = path2.join(dir, "voice-host");
+  try {
+    const v = fs2.readFileSync(file, "utf8").trim();
+    if (LABEL_RE.test(v)) return v;
+  } catch {
+  }
+  const label = "a8-" + randomBytes(12).toString("hex");
+  try {
+    fs2.mkdirSync(dir, { recursive: true, mode: 448 });
+    fs2.writeFileSync(file, label + "\n", { mode: 384 });
+    fs2.chmodSync(file, 384);
+  } catch {
+  }
+  return label;
+}
+function writeVoiceRedirect(pageUrl, parent = os2.tmpdir()) {
+  const dir = fs2.mkdtempSync(path2.join(parent, "accelr8-voice-"));
+  const file = path2.join(dir, "voice.html");
+  fs2.writeFileSync(
+    file,
+    `<!doctype html><meta charset="utf-8"><meta name="referrer" content="no-referrer"><title>accelr8 voice</title><meta http-equiv="refresh" content="0;url=${pageUrl}"><script>location.replace(${JSON.stringify(pageUrl)})</script>
+`,
+    { mode: 384, flag: "wx" }
+  );
+  return { url: pathToFileURL(file).href, dir };
+}
+async function defaultClientJs() {
+  const m = await import("./livekit-client-bundle-HLYFRJB2.js");
+  return m.LIVEKIT_CLIENT_JS;
+}
+function listen(server, port, host) {
+  return new Promise((resolve, reject) => {
+    const onError = (e) => {
+      server.off("listening", onListening);
+      reject(e);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve(server.address().port);
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, host);
+  });
+}
+async function bindLoopback(handler, ports, onSocket) {
+  let lastErr = null;
+  for (const p of [...ports, 0, 0, 0]) {
+    const v4 = http.createServer(handler);
+    v4.on("connection", onSocket);
+    let port;
+    try {
+      port = await listen(v4, p, "127.0.0.1");
+    } catch (e) {
+      lastErr = e;
+      v4.close();
+      continue;
+    }
+    const v6 = http.createServer(handler);
+    v6.on("connection", onSocket);
+    try {
+      await listen(v6, port, "::1");
+      return { servers: [v4, v6], port };
+    } catch (e) {
+      if (e?.code !== "EADDRINUSE") {
+        v6.close();
+        return { servers: [v4], port };
+      }
+      lastErr = e;
+      v4.close();
+      v6.close();
+    }
+  }
+  throw lastErr ?? new Error("no port");
+}
+async function openVoiceWindow(o) {
+  if (!isVoiceUrl(o.liveKitUrl)) throw new Error("bad LiveKit url");
+  const nonce = randomBytes(24).toString("base64url");
+  const cookieSecret = Buffer.from(randomBytes(24).toString("base64url"));
+  const label = voiceHostLabel(o.stateDir);
+  const styleHash = createHash("sha256").update(VOICE_PAGE_CSS, "utf8").digest("base64");
+  const graceMs = o.graceMs ?? 8e3;
+  const leaveTimeoutMs = o.leaveTimeoutMs ?? 3e3;
+  const store = new VoiceStore({ ...initialVoiceState(o.room, o.identity) });
+  const loadJs = o.loadClientJs ?? defaultClientJs;
+  let port = 0;
+  let servers = [];
+  let finished = false;
+  let wantMuted = o.startMuted ?? true;
+  let pageHost = null;
+  let loads = 0;
+  let redirectDir = null;
+  let attach = null;
+  let sse = null;
+  let closing = false;
+  let everAttached = false;
+  let graceTimer = null;
+  let loadTimer = null;
+  let pingTimer = null;
+  let tokenWork = null;
+  const pending = /* @__PURE__ */ new Map();
+  const sockets = /* @__PURE__ */ new Set();
+  let resolveEnded;
+  const ended = new Promise((r) => {
+    resolveEnded = r;
+  });
+  let clientJs = null;
+  const log = [];
+  const note = (s) => {
+    log.push(`${(/* @__PURE__ */ new Date()).toISOString().slice(11, 19)} ${s}`);
+    if (log.length > 8) log.shift();
+  };
+  const deny = (res, code) => {
+    res.writeHead(code, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store" });
+    res.end(code === 404 ? "This voice window is closed. Run /voice in accelr8 to open a new one." : "no");
+  };
+  const json = (res, code, body) => {
+    res.writeHead(code, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+    res.end(JSON.stringify(body));
+  };
+  const event = (name, data) => {
+    if (!sse || sse.writableEnded) return false;
+    sse.write(`event: ${name}
+data: ${JSON.stringify(data)}
+
+`);
+    return true;
+  };
+  const dropRedirect = () => {
+    if (!redirectDir) return;
+    try {
+      fs2.rmSync(redirectDir, { recursive: true, force: true });
+    } catch {
+    }
+    redirectDir = null;
+  };
+  const hasCookie = (req) => {
+    for (const part of String(req.headers.cookie ?? "").split(";")) {
+      const i = part.indexOf("=");
+      if (i < 0 || part.slice(0, i).trim() !== COOKIE) continue;
+      const v = Buffer.from(part.slice(i + 1).trim());
+      if (v.length === cookieSecret.length && timingSafeEqual(v, cookieSecret)) return true;
+    }
+    return false;
+  };
+  function finish(reason, error = null, pageReason) {
+    if (finished) return;
+    finished = true;
+    note(`ended: ${reason}${error ? " \xB7 " + error : ""}`);
+    for (const t2 of [graceTimer, loadTimer]) if (t2) clearTimeout(t2);
+    if (pingTimer) clearInterval(pingTimer);
+    graceTimer = loadTimer = pingTimer = null;
+    store.update({ connection: "disconnected", endReason: reason, ...error ? { error } : {} });
+    for (const [, p] of pending) {
+      clearTimeout(p.timer);
+      p.resolve([]);
+    }
+    pending.clear();
+    event("bye", { reason: pageReason ?? (reason === "left" ? "you left voice in accelr8" : "accelr8 ended voice") });
+    try {
+      sse?.end();
+    } catch {
+    }
+    sse = null;
+    attach = null;
+    dropRedirect();
+    for (const s of servers) s.close();
+    const t = setTimeout(() => {
+      for (const s of sockets) s.destroy();
+    }, 300);
+    t.unref();
+    resolveEnded(reason);
+  }
+  function pageGone(why) {
+    if (finished) return;
+    note(`page gone (${why})`);
+    attach = null;
+    sse = null;
+    closing = false;
+    if (pingTimer) {
+      clearInterval(pingTimer);
+      pingTimer = null;
+    }
+    wantMuted = true;
+    store.update({ connection: "connecting", needsClick: false, participants: [], playbackBlocked: false, muted: true });
+    if (!graceTimer) {
+      graceTimer = setTimeout(() => {
+        graceTimer = null;
+        if (!attach) finish("window_closed");
+      }, graceMs);
+      graceTimer.unref?.();
+    }
+  }
+  function readBody(req) {
+    return new Promise((resolve, reject) => {
+      let size = 0;
+      const chunks = [];
+      req.on("data", (c) => {
+        size += c.length;
+        if (size > MAX_BODY) {
+          reject(new Error("too big"));
+          req.destroy();
+          return;
+        }
+        chunks.push(c);
+      });
+      req.on("end", () => {
+        try {
+          resolve(JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}"));
+        } catch (e) {
+          reject(e);
+        }
+      });
+      req.on("error", reject);
+    });
+  }
+  function openEvents(req, res) {
+    if (sse && !closing) return deny(res, 409);
+    if (sse) {
+      try {
+        sse.end();
+      } catch {
+      }
+    }
+    const id = randomBytes(12).toString("base64url");
+    attach = id;
+    sse = res;
+    closing = false;
+    everAttached = true;
+    if (graceTimer) {
+      clearTimeout(graceTimer);
+      graceTimer = null;
+    }
+    if (loadTimer) {
+      clearTimeout(loadTimer);
+      loadTimer = null;
+    }
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-store",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no"
+    });
+    res.write("retry: 1000\n\n");
+    event("hello", { attach: id, muted: wantMuted });
+    note("page attached");
+    if (pingTimer) clearInterval(pingTimer);
+    pingTimer = setInterval(() => {
+      if (sse === res) res.write(": ping\n\n");
+    }, 15e3);
+    pingTimer.unref?.();
+    req.on("close", () => {
+      if (sse === res) pageGone("closed");
+    });
+  }
+  async function onPost(sub, req, res) {
+    const type = String(req.headers["content-type"] ?? "");
+    if (sub !== "/closing" && !type.startsWith("application/json")) return deny(res, 415);
+    let body;
+    try {
+      body = await readBody(req);
+    } catch {
+      return deny(res, 400);
+    }
+    if (finished) return deny(res, 404);
+    if (!body || typeof body !== "object" || typeof body.attach !== "string" || body.attach !== attach) return deny(res, 409);
+    switch (sub) {
+      case "/state": {
+        const patch = normalizeVoiceState(body);
+        if (patch.connection === "disconnected") {
+          finish(patch.endReason ?? "error", patch.error ?? null);
+        } else {
+          if (patch.connection === "connected" && store.snapshot().connection !== "connected") note("in the call");
+          store.update(patch);
+        }
+        return json(res, 200, { ok: true });
+      }
+      case "/join": {
+        try {
+          tokenWork = tokenWork ?? o.getToken();
+          const token = await tokenWork;
+          if (finished || body.attach !== attach) return deny(res, 409);
+          note("join clicked \xB7 pass handed over");
+          return json(res, 200, { token });
+        } catch (e) {
+          const m = e instanceof Error ? e.message : String(e);
+          note("no voice pass: " + m);
+          return json(res, 503, { error: m });
+        } finally {
+          tokenWork = null;
+        }
+      }
+      case "/reply": {
+        const p = typeof body.id === "string" ? pending.get(body.id) : void 0;
+        if (p) {
+          pending.delete(body.id);
+          clearTimeout(p.timer);
+          p.resolve(Array.isArray(body.devices) ? body.devices.slice(0, 64).flatMap((d) => d && typeof d.id === "string" ? [{
+            id: d.id.slice(0, 256),
+            label: String(d.label ?? "").replace(/[\u0000-\u001f\u007f-\u009f]/g, "").slice(0, 80) || "unnamed device",
+            kind: d.kind === "audiooutput" ? "audiooutput" : "audioinput",
+            isDefault: d.isDefault === true
+          }] : []) : []);
+        }
+        return json(res, 200, { ok: true });
+      }
+      case "/closing": {
+        closing = true;
+        note("page closing");
+        return json(res, 200, { ok: true });
+      }
+    }
+    return deny(res, 404);
+  }
+  const common = { "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff", "Referrer-Policy": "no-referrer" };
+  function servePage(req, res, host) {
+    const reload = loads > 0 && host === pageHost && hasCookie(req);
+    if (loads > 0 && !reload) {
+      note("a second page load without the cookie");
+      deny(res, 404);
+      finish("error", "another program tried to open this voice window", "another program tried to open this voice window");
+      return;
+    }
+    const first = loads === 0;
+    loads++;
+    if (first) {
+      pageHost = host;
+      dropRedirect();
+      note("page loaded");
+    }
+    res.writeHead(200, {
+      ...common,
+      "Content-Type": "text/html; charset=utf-8",
+      "Content-Security-Policy": voicePageCsp(o.liveKitUrl, styleHash),
+      "Cross-Origin-Opener-Policy": "same-origin",
+      "X-Frame-Options": "DENY",
+      "Permissions-Policy": "microphone=(self), camera=(), geolocation=()",
+      // Lax, not Strict: a reload must carry it, and the first load came from
+      // a file:// page (another site). Cross-site requests are refused above.
+      ...first ? { "Set-Cookie": `${COOKIE}=${cookieSecret.toString()}; Path=/voice/${nonce}; HttpOnly; SameSite=Lax` } : {}
+    });
+    res.end(voicePageHtml({ nonce, liveKitUrl: o.liveKitUrl, title: o.title, bridgeLossMs: o.bridgeLossMs }));
+  }
+  const handle = (req, res) => {
+    const host = String(req.headers.host ?? "").toLowerCase();
+    const hosts = pageHost ? [pageHost] : [`${label}.localhost:${port}`, `127.0.0.1:${port}`];
+    if (!hosts.includes(host)) return deny(res, 421);
+    let pathname;
+    try {
+      pathname = new URL(req.url ?? "/", "http://x").pathname;
+    } catch {
+      return deny(res, 400);
+    }
+    const m = /^\/voice\/([A-Za-z0-9_-]{16,64})(\/[a-z-]+(?:\.js)?)?$/.exec(pathname);
+    const sub = m?.[2] ?? "";
+    const origin2 = req.headers.origin;
+    const site = req.headers["sec-fetch-site"];
+    const mode = req.headers["sec-fetch-mode"];
+    const dest = req.headers["sec-fetch-dest"];
+    const navigation = req.method === "GET" && sub === "" && (mode === void 0 || mode === "navigate") && (dest === void 0 || dest === "document");
+    if (typeof site === "string" && site !== "same-origin" && site !== "none" && !(navigation && site === "cross-site")) return deny(res, 403);
+    if (origin2 !== void 0 && origin2 !== `http://${host}`) return deny(res, 403);
+    if (!m || m[1] !== nonce || finished) return deny(res, 404);
+    if (req.method === "POST") {
+      if (origin2 === void 0) return deny(res, 403);
+      if (!hasCookie(req)) return deny(res, 403);
+      void onPost(sub, req, res).catch(() => {
+        if (!res.headersSent) deny(res, 500);
+      });
+      return;
+    }
+    if (req.method !== "GET") return deny(res, 405);
+    if (sub === "") return servePage(req, res, host);
+    if (!hasCookie(req)) return deny(res, 403);
+    switch (sub) {
+      case "/app.js":
+        res.writeHead(200, { ...common, "Content-Type": "text/javascript; charset=utf-8" });
+        res.end(VOICE_PAGE_JS);
+        return;
+      case "/livekit-client.js": {
+        const send = (js) => {
+          res.writeHead(200, { ...common, "Content-Type": "text/javascript; charset=utf-8" });
+          res.end(js);
+        };
+        if (clientJs) return send(clientJs);
+        loadJs().then((js) => {
+          clientJs = js;
+          send(js);
+        }, () => deny(res, 500));
+        return;
+      }
+      case "/events":
+        return openEvents(req, res);
+    }
+    return deny(res, 404);
+  };
+  const onSocket = (s) => {
+    sockets.add(s);
+    s.once("close", () => sockets.delete(s));
+  };
+  try {
+    ({ servers, port } = await bindLoopback(handle, o.ports ?? VOICE_PORTS, onSocket));
+  } catch (e) {
+    throw new Error("could not start the local voice page: " + (e instanceof Error ? e.message : String(e)));
+  }
+  const appPage = `http://${label}.localhost:${port}/voice/${nonce}`;
+  const plainPage = `http://127.0.0.1:${port}/voice/${nonce}`;
+  let appTarget = appPage;
+  try {
+    const r = writeVoiceRedirect(appPage, o.tmpDir);
+    redirectDir = r.dir;
+    appTarget = r.url;
+  } catch (e) {
+    note("no redirect file (" + (e instanceof Error ? e.message : String(e)) + "): the app window gets the page URL");
+  }
+  let openedWith = "";
+  try {
+    openedWith = (await (o.open ?? openVoicePage)({ app: appTarget, browser: plainPage })).method;
+  } catch (e) {
+    finished = true;
+    dropRedirect();
+    for (const s of servers) s.close();
+    for (const s of sockets) s.destroy();
+    throw e;
+  }
+  note(`window opened (${openedWith})`);
+  loadTimer = setTimeout(() => {
+    loadTimer = null;
+    if (!everAttached) finish("window_closed", "the voice window did not open");
+  }, o.loadTimeoutMs ?? 45e3);
+  loadTimer.unref?.();
+  const origin = () => `http://${pageHost ?? (openedWith === "default-browser" ? `127.0.0.1:${port}` : `${label}.localhost:${port}`)}`;
+  const controller = {
+    kind: "window",
+    openedWith,
+    get origin() {
+      return origin();
+    },
+    ended,
+    snapshot: () => store.snapshot(),
+    subscribe: (fn) => store.subscribe(fn),
+    async setMuted(muted) {
+      if (finished) return;
+      wantMuted = muted;
+      event("cmd", { cmd: "mute", muted });
+    },
+    listDevices(kind = "audioinput") {
+      if (finished || !attach) return Promise.resolve([]);
+      const id = randomBytes(8).toString("hex");
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          resolve([]);
+        }, 3e3);
+        timer.unref?.();
+        pending.set(id, { resolve, timer });
+        if (!event("cmd", { cmd: "devices", id, kind })) {
+          clearTimeout(timer);
+          pending.delete(id);
+          resolve([]);
+        }
+      });
+    },
+    async setInputDevice(id) {
+      if (!finished) event("cmd", { cmd: "device", id: String(id).slice(0, 256) });
+    },
+    async leave() {
+      if (finished) {
+        await ended;
+        return;
+      }
+      if (!event("cmd", { cmd: "leave" })) {
+        finish("left");
+        await ended;
+        return;
+      }
+      const t = setTimeout(() => finish("left"), leaveTimeoutMs);
+      t.unref?.();
+      await ended;
+      clearTimeout(t);
+    },
+    quit() {
+      finish("left");
+    },
+    debug() {
+      const s = store.snapshot();
+      return [
+        `transport: livekit \xB7 voice window (${openedWith})`,
+        // the label is this install's, not for bug reports
+        `page: ${finished ? "closed" : attach ? "attached" : everAttached ? "away, waiting for it" : "not loaded yet"} \xB7 ${origin().replace(/a8-[0-9a-f]+/, "a8-\u2026")}`,
+        `call: ${s.connection}${s.needsClick ? " \xB7 waiting for a click on Join" : ""}${s.muted ? " \xB7 muted" : " \xB7 mic on"}`,
+        `people: ${s.participants.length}${s.error ? " \xB7 " + s.error : ""}`,
+        ...log.slice(-4)
+      ];
+    }
+  };
+  return controller;
+}
+export {
+  VOICE_PORTS,
+  openVoiceWindow,
+  voiceHostLabel,
+  writeVoiceRedirect
+};