accelr8 3.8.2 → 4.0.0-next.1

package/dist/chunks/livekit-terminal-22Q2NFB5.js

@@ -0,0 +1,535 @@
+#!/usr/bin/env node
+import {
+  toWsUrl
+} from "./chunk-EQPM4FIJ.js";
+import {
+  RTC_NODE,
+  RTC_NODE_VERSION,
+  VoiceStore,
+  decodeVoiceMetadata,
+  initialVoiceState,
+  mapLiveKitDisconnect,
+  parseVoiceIdentity,
+  rtcNodeMissingHint,
+  sanitizeVoiceName
+} from "./chunk-CAQJPW54.js";
+import {
+  captureArgs,
+  killHelper,
+  listMicDevices,
+  spawnHelper,
+  vlog,
+  voiceSinkCommand
+} from "./chunk-UMPU6SAD.js";
+import "./chunk-62O2F73J.js";
+
+// src/livekit-terminal.ts
+import { createRequire } from "node:module";
+import path from "node:path";
+var TERMINAL_RATE = 48e3;
+var FRAME_SAMPLES = 480;
+var FRAME_BYTES = FRAME_SAMPLES * 2;
+var SEND_QUEUE_FRAMES = 10;
+var JITTER_TARGET = 4;
+var JITTER_MAX = 12;
+var SINK_MAX_BYTES = TERMINAL_RATE * 2 / 4;
+var HEADPHONES_ONLY = "headphones only: in-terminal voice has no echo cancellation";
+var rtcLoading = null;
+function loadRtcNode() {
+  if (!rtcLoading) {
+    rtcLoading = (async () => {
+      const name = RTC_NODE;
+      const mod = await import(name);
+      try {
+        const req = createRequire(import.meta.url);
+        const log = req(path.join(path.dirname(req.resolve(name)), "log.cjs")).log;
+        if (log) log.level = "silent";
+      } catch {
+      }
+      return mod;
+    })();
+    rtcLoading.catch(() => {
+      rtcLoading = null;
+    });
+  }
+  return rtcLoading;
+}
+var JitterQueue = class {
+  frames = [];
+  playing = false;
+  shed = 0;
+  push(f) {
+    this.frames.push(f);
+    if (this.frames.length > JITTER_MAX) {
+      const drop = this.frames.length - JITTER_TARGET;
+      this.frames.splice(0, drop);
+      this.shed += drop;
+    }
+  }
+  /** One frame for this tick, or null (prebuffering or underrun). */
+  pull() {
+    if (!this.playing) {
+      if (this.frames.length < JITTER_TARGET) return null;
+      this.playing = true;
+    }
+    const f = this.frames.shift() ?? null;
+    if (!f) this.playing = false;
+    return f;
+  }
+};
+function mixFrames(frames, samples = FRAME_SAMPLES) {
+  const out = new Int16Array(samples);
+  if (frames.length === 0) return out;
+  for (let i = 0; i < samples; i++) {
+    let v = 0;
+    for (const f of frames) v += f[i] ?? 0;
+    out[i] = v > 32767 ? 32767 : v < -32768 ? -32768 : v;
+  }
+  return out;
+}
+var PcmFramer = class {
+  rest = Buffer.alloc(0);
+  push(chunk, onFrame) {
+    let buf = this.rest.length ? Buffer.concat([this.rest, chunk]) : chunk;
+    while (buf.length >= FRAME_BYTES) {
+      const f = new Int16Array(FRAME_SAMPLES);
+      Buffer.from(f.buffer).set(buf.subarray(0, FRAME_BYTES));
+      onFrame(f);
+      buf = buf.subarray(FRAME_BYTES);
+    }
+    this.rest = Buffer.from(buf);
+  }
+};
+var FrameClock = class {
+  constructor(onFrame, now = () => performance.now()) {
+    this.onFrame = onFrame;
+    this.now = now;
+  }
+  onFrame;
+  now;
+  timer = null;
+  start = 0;
+  done = 0;
+  run() {
+    this.start = this.now();
+    this.done = 0;
+    this.timer = setInterval(() => this.tick(), 5);
+    this.timer.unref?.();
+  }
+  tick() {
+    const due = Math.floor((this.now() - this.start) / 10);
+    let n = due - this.done;
+    if (n > 10) {
+      this.done = due - 1;
+      n = 1;
+    }
+    for (; n > 0; n--) {
+      this.done++;
+      this.onFrame();
+    }
+  }
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+  }
+};
+async function joinTerminalVoice(o) {
+  const platform = o.platform ?? process.platform;
+  const spawn = o.spawn ?? spawnHelper;
+  if (!o.tools.ffmpegPath) throw new Error("in-terminal voice needs ffmpeg");
+  const sinkCmd = voiceSinkCommand(o.tools, TERMINAL_RATE, platform);
+  if (!sinkCmd) throw new Error("in-terminal voice needs ffplay (or ffmpeg with CoreAudio) to play the call");
+  const rtc = o.rtc ?? await loadRtcNode();
+  const store = new VoiceStore(initialVoiceState(o.room, o.identity));
+  const room = new rtc.Room();
+  const queues = /* @__PURE__ */ new Map();
+  const readers = /* @__PURE__ */ new Map();
+  const speaking = /* @__PURE__ */ new Set();
+  let device = o.device;
+  let muted = true;
+  let ended = false;
+  let everConnected = false;
+  let leaving = null;
+  let sink = null;
+  let sinkDropped = 0;
+  let sinkRestarts = [];
+  let mic = null;
+  let source = null;
+  let track = null;
+  let trackSid = null;
+  let sendQueue = [];
+  let sendDropped = 0;
+  let pumping = false;
+  let sent = 0;
+  let chain = Promise.resolve();
+  let resolveEnded;
+  const endedP = new Promise((r) => {
+    resolveEnded = r;
+  });
+  const clock = new FrameClock(() => tickPlayback());
+  const serial = (work) => {
+    const next = chain.then(() => ended ? void 0 : work());
+    chain = next.catch(() => void 0);
+    return next;
+  };
+  const micPub = (p) => {
+    let audio;
+    for (const pub of p.trackPublications.values()) {
+      if (pub.source === rtc.TrackSource.SOURCE_MICROPHONE) return pub;
+      if (!audio && pub.kind === rtc.TrackKind.KIND_AUDIO) audio = pub;
+    }
+    return audio;
+  };
+  const person = (p, isLocal) => {
+    const m = decodeVoiceMetadata(p.metadata);
+    const isMuted = isLocal ? muted : (() => {
+      const pub = micPub(p);
+      return !pub || pub.muted === true;
+    })();
+    return {
+      identity: p.identity,
+      sid: m?.sid || parseVoiceIdentity(p.identity)?.sid || null,
+      userId: m?.userId || null,
+      name: sanitizeVoiceName(m?.name || p.name || ""),
+      color: m ? m.color : null,
+      client: m ? m.client : null,
+      isLocal,
+      muted: isMuted,
+      speaking: !isMuted && speaking.has(p.identity)
+    };
+  };
+  const refresh = () => {
+    if (ended) return;
+    const list = [];
+    if (room.localParticipant) list.push(person(room.localParticipant, true));
+    for (const p of room.remoteParticipants.values()) list.push(person(p, false));
+    const connection = room.connectionState === rtc.ConnectionState.CONN_CONNECTED ? "connected" : room.connectionState === rtc.ConnectionState.CONN_RECONNECTING ? "reconnecting" : everConnected ? "reconnecting" : "connecting";
+    store.update({ participants: list, connection, muted, inputDeviceId: device ?? null });
+  };
+  function startSink() {
+    if (ended || sink) return;
+    const child = spawn(sinkCmd.bin, sinkCmd.args, ["pipe", "ignore", "pipe"], { group: true });
+    sink = child;
+    child.stdin?.on("error", () => {
+    });
+    child.on("error", () => {
+      if (sink === child) sink = null;
+    });
+    child.on("close", (code) => {
+      if (sink !== child) return;
+      sink = null;
+      vlog(Date.now(), "playback", "terminal sink exited", { code });
+      if (ended) return;
+      const now = Date.now();
+      sinkRestarts = sinkRestarts.filter((t) => now - t < 6e4);
+      if (sinkRestarts.length >= 5) {
+        store.update({ error: "the speaker player keeps stopping \xB7 /voice debug" });
+        return;
+      }
+      sinkRestarts.push(now);
+      setTimeout(startSink, 250).unref?.();
+    });
+    vlog(Date.now(), "playback", "terminal sink started", { kind: sinkCmd.kind });
+  }
+  function tickPlayback() {
+    if (ended) return;
+    const frames = [];
+    for (const q of queues.values()) {
+      const f = q.pull();
+      if (f) frames.push(f);
+    }
+    const sin = sink?.stdin;
+    if (!sin || sin.destroyed || !sin.writable) return;
+    if (sin.writableLength > SINK_MAX_BYTES) {
+      sinkDropped++;
+      return;
+    }
+    const mixed = mixFrames(frames);
+    try {
+      sin.write(Buffer.from(mixed.buffer, mixed.byteOffset, mixed.byteLength));
+    } catch {
+    }
+  }
+  function listen(trackObj, sid, identity) {
+    if (readers.has(sid) || ended) return;
+    const stream = new rtc.AudioStream(trackObj, { sampleRate: TERMINAL_RATE, numChannels: 1, frameSizeMs: 10 });
+    const reader = stream.getReader();
+    readers.set(sid, reader);
+    let q = queues.get(identity);
+    if (!q) {
+      q = new JitterQueue();
+      queues.set(identity, q);
+    }
+    const queue = q;
+    void (async () => {
+      try {
+        for (; ; ) {
+          const { value, done } = await reader.read();
+          if (done || !value || ended) break;
+          let data = value.data;
+          if (value.channels > 1) {
+            const mono = new Int16Array(value.samplesPerChannel);
+            for (let i = 0; i < mono.length; i++) {
+              let s = 0;
+              for (let c = 0; c < value.channels; c++) s += data[i * value.channels + c];
+              mono[i] = s / value.channels;
+            }
+            data = mono;
+          }
+          queue.push(data);
+        }
+      } catch {
+      }
+    })();
+  }
+  function unlisten(sid, identity) {
+    const r = readers.get(sid);
+    readers.delete(sid);
+    void r?.cancel?.().catch(() => void 0);
+    if (identity) queues.delete(identity);
+  }
+  function pump() {
+    if (pumping) return;
+    pumping = true;
+    void (async () => {
+      try {
+        while (sendQueue.length && source && !ended && !muted) {
+          const f = sendQueue.shift();
+          await source.captureFrame(new rtc.AudioFrame(f, TERMINAL_RATE, 1, FRAME_SAMPLES));
+          sent++;
+        }
+      } catch (e) {
+        vlog(Date.now(), "transmit", "captureFrame failed", { err: e instanceof Error ? e.message : String(e) });
+      } finally {
+        pumping = false;
+      }
+    })();
+  }
+  function startMic() {
+    if (mic || ended) return;
+    const framer = new PcmFramer();
+    const child = spawn(o.tools.ffmpegPath, captureArgs(platform, device, TERMINAL_RATE), ["ignore", "pipe", "pipe"]);
+    mic = child;
+    let tail = "";
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (c) => {
+      tail = (tail + c).slice(-300);
+    });
+    child.stdout?.on("data", (chunk) => {
+      if (mic !== child || muted) return;
+      framer.push(chunk, (f) => {
+        sendQueue.push(f);
+        if (sendQueue.length > SEND_QUEUE_FRAMES) {
+          sendDropped += sendQueue.length - SEND_QUEUE_FRAMES;
+          sendQueue = sendQueue.slice(-SEND_QUEUE_FRAMES);
+        }
+      });
+      pump();
+    });
+    child.on("error", () => {
+      if (mic === child) mic = null;
+    });
+    child.on("close", (code) => {
+      if (mic !== child) return;
+      mic = null;
+      if (!ended && !muted) {
+        store.update({ error: "the mic stopped: " + (tail.trim().split("\n").pop() || `ffmpeg exited ${code}`) });
+        void serial(() => setMutedNow(true));
+      }
+    });
+  }
+  function stopMic() {
+    const m = mic;
+    mic = null;
+    sendQueue = [];
+    if (!m) return;
+    try {
+      m.stdout?.destroy();
+    } catch {
+    }
+    killHelper(m, "SIGINT");
+    setTimeout(() => killHelper(m, "SIGKILL"), 300).unref?.();
+  }
+  async function setMutedNow(m) {
+    if (m === muted) {
+      refresh();
+      return;
+    }
+    if (m) {
+      muted = true;
+      stopMic();
+      const sid = trackSid;
+      const t = track;
+      trackSid = null;
+      track = null;
+      source = null;
+      if (sid) await room.localParticipant?.unpublishTrack(sid, true).catch(() => void 0);
+      await t?.close?.(true).catch(() => void 0);
+    } else {
+      if (!room.localParticipant) throw new Error("not connected");
+      const s = new rtc.AudioSource(TERMINAL_RATE, 1, 200);
+      const t = rtc.LocalAudioTrack.createAudioTrack("microphone", s);
+      const pub = await room.localParticipant.publishTrack(t, new rtc.TrackPublishOptions({ source: rtc.TrackSource.SOURCE_MICROPHONE, dtx: true, red: true }));
+      if (ended) {
+        await t.close?.(true).catch(() => void 0);
+        return;
+      }
+      source = s;
+      track = t;
+      trackSid = pub?.sid ?? t.sid ?? null;
+      muted = false;
+      startMic();
+    }
+    refresh();
+  }
+  function teardown(reason) {
+    if (ended) return;
+    ended = true;
+    clock.stop();
+    stopMic();
+    const s = sink;
+    sink = null;
+    if (s) {
+      try {
+        s.stdin?.end();
+      } catch {
+      }
+      killHelper(s, "SIGKILL");
+    }
+    for (const sid of [...readers.keys()]) unlisten(sid);
+    queues.clear();
+    store.update({ connection: "disconnected", endReason: reason });
+    resolveEnded(reason);
+  }
+  const E = rtc.RoomEvent;
+  room.on(E.ParticipantConnected, refresh);
+  room.on(E.ParticipantDisconnected, (p) => {
+    queues.delete(p.identity);
+    speaking.delete(p.identity);
+    refresh();
+  });
+  room.on(E.TrackSubscribed, (t, pub, p) => {
+    if (t.kind === rtc.TrackKind.KIND_AUDIO && pub.sid) listen(t, pub.sid, p.identity);
+    refresh();
+  });
+  room.on(E.TrackUnsubscribed, (_t, pub, p) => {
+    if (pub.sid) unlisten(pub.sid, p.identity);
+    refresh();
+  });
+  for (const ev of [
+    "TrackPublished",
+    "TrackUnpublished",
+    "TrackMuted",
+    "TrackUnmuted",
+    "ParticipantMetadataChanged",
+    "ParticipantNameChanged",
+    "ConnectionStateChanged",
+    "Reconnecting",
+    "Reconnected"
+  ]) {
+    if (E[ev]) room.on(E[ev], refresh);
+  }
+  room.on(E.ActiveSpeakersChanged, (list) => {
+    speaking.clear();
+    for (const p of list ?? []) speaking.add(p.identity);
+    refresh();
+  });
+  room.on(E.Disconnected, (reason) => {
+    if (!leaving) teardown(mapLiveKitDisconnect(reason, everConnected));
+  });
+  const timeoutMs = o.connectTimeoutMs ?? 15e3;
+  const connecting = room.connect(toWsUrl(o.url), o.token, { autoSubscribe: true, dynacast: false });
+  let timer = null;
+  try {
+    await Promise.race([connecting, new Promise((_, rej) => {
+      timer = setTimeout(() => rej(new Error("could not reach the voice server")), timeoutMs);
+    })]);
+  } catch (e) {
+    teardown("error");
+    void connecting.then(() => room.disconnect().catch(() => void 0), () => void 0);
+    throw e;
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+  everConnected = true;
+  startSink();
+  if (o.timers !== false) clock.run();
+  if (o.startMuted === false) await serial(() => setMutedNow(false));
+  refresh();
+  const controller = {
+    kind: "terminal",
+    ended: endedP,
+    snapshot: () => store.snapshot(),
+    subscribe: (fn) => store.subscribe(fn),
+    async setMuted(m) {
+      await serial(() => setMutedNow(m)).catch((e) => {
+        store.update({ error: "could not change the mic: " + (e instanceof Error ? e.message : String(e)) });
+      });
+    },
+    async listDevices(kind = "audioinput") {
+      if (kind !== "audioinput") return [];
+      return listMicDevices().map((d) => ({ id: d.index, label: d.name, kind: "audioinput", isDefault: false }));
+    },
+    async setInputDevice(id) {
+      await serial(async () => {
+        device = id || void 0;
+        if (mic) {
+          stopMic();
+          startMic();
+        }
+        refresh();
+      });
+    },
+    leave() {
+      if (!leaving) {
+        leaving = (async () => {
+          await chain;
+          const wasEnded = ended;
+          teardown("left");
+          if (!wasEnded) await room.disconnect().catch(() => void 0);
+        })();
+      }
+      return leaving;
+    },
+    quit() {
+      if (!leaving) leaving = (async () => {
+        teardown("left");
+        await room.disconnect().catch(() => void 0);
+      })();
+    },
+    tickPlayback,
+    helperPids: () => [mic, sink].map((c) => c?.pid).filter((p) => typeof p === "number"),
+    debug() {
+      const s = store.snapshot();
+      let shed = 0;
+      for (const q of queues.values()) shed += q.shed;
+      return [
+        `transport: livekit \xB7 in this terminal (${HEADPHONES_ONLY})`,
+        `call: ${s.connection}${muted ? " \xB7 muted (mic off)" : " \xB7 mic on"} \xB7 people: ${s.participants.length}`,
+        `mic: ${device ?? "default"} \xB7 sent ${sent} frames \xB7 dropped ${sendDropped}`,
+        `sink: ${sinkCmd.kind}${sink ? "" : " (down)"} \xB7 speakers ${queues.size} \xB7 shed ${shed} \xB7 sink drops ${sinkDropped}`,
+        `helpers: ${controller.helperPids().join(" ") || "none"}`
+      ];
+    }
+  };
+  return controller;
+}
+export {
+  FRAME_BYTES,
+  FRAME_SAMPLES,
+  FrameClock,
+  HEADPHONES_ONLY,
+  JITTER_MAX,
+  JITTER_TARGET,
+  JitterQueue,
+  PcmFramer,
+  RTC_NODE,
+  RTC_NODE_VERSION,
+  SEND_QUEUE_FRAMES,
+  SINK_MAX_BYTES,
+  TERMINAL_RATE,
+  joinTerminalVoice,
+  loadRtcNode,
+  mixFrames,
+  rtcNodeMissingHint
+};