accelr8 3.1.1 → 3.3.0

package/dist/chunks/chunk-HY6ULYGH.js

@@ -0,0 +1,559 @@
+#!/usr/bin/env node
+
+// src/voicelog.ts
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var logPath = null;
+var enabled = true;
+function file() {
+  if (!logPath) {
+    const dir = path.join(os.homedir(), ".accelr8");
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+    } catch {
+    }
+    logPath = path.join(dir, "voice.log");
+  }
+  return logPath;
+}
+function stamp(nowMs) {
+  const d = new Date(nowMs);
+  const p = (n, w = 2) => String(n).padStart(w, "0");
+  return `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}.${p(d.getMilliseconds(), 3)}`;
+}
+function vlog(nowMs, stage, msg, data) {
+  if (!enabled) return;
+  try {
+    const extra = data ? " " + Object.entries(data).map(([k, v]) => `${k}=${String(v).slice(0, 80)}`).join(" ") : "";
+    fs.appendFileSync(file(), `${stamp(nowMs)} [${stage}] ${msg}${extra}
+`);
+  } catch {
+  }
+}
+function vlogSession(nowMs, header) {
+  vlog(nowMs, "session", "\u2500\u2500\u2500\u2500 voice session \u2500\u2500\u2500\u2500", header);
+}
+function voiceLogPath() {
+  return file();
+}
+
+// src/voice.ts
+import { spawn, spawnSync } from "node:child_process";
+import fs2 from "node:fs";
+import path2 from "node:path";
+var SAMPLE_RATE = 16e3;
+var CHUNK_BYTES = 1280;
+var KILL_GRACE_MS = 300;
+var SPEAKER_IDLE_MS = 2e3;
+var PREBUFFER_BYTES = 4800;
+var DRAIN_KILL_MS = 2e3;
+var MAX_PLAYERS = 8;
+var STDERR_TAIL = 400;
+var VERIFY_MIN_BYTES = SAMPLE_RATE * 2 / 10;
+function playbackArgs(ffplayPath) {
+  const ch = ffplayChannelFlag(ffplayPath);
+  return [
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-nodisp",
+    "-sync",
+    "audio",
+    "-infbuf",
+    "-f",
+    "s16le",
+    "-ar",
+    String(SAMPLE_RATE),
+    ...ch,
+    "-i",
+    "-"
+  ];
+}
+var chFlagCache = null;
+function ffplayChannelFlag(ffplayPath) {
+  if (chFlagCache) return chFlagCache;
+  let modern = true;
+  try {
+    const out = spawnSync(ffplayPath, ["-hide_banner", "-version"], { encoding: "utf8", timeout: 3e3 });
+    const m = ((out.stdout || "") + (out.stderr || "")).match(/version\s+n?(\d+)\.(\d+)/i);
+    if (m) {
+      const major = +m[1], minor = +m[2];
+      modern = major > 5 || major === 5 && minor >= 1;
+    }
+  } catch {
+  }
+  chFlagCache = modern ? ["-ch_layout", "mono"] : ["-ac", "1"];
+  return chFlagCache;
+}
+function detectVoiceTools() {
+  const ffmpegPath = which("ffmpeg");
+  const ffplayPath = which("ffplay");
+  const out = { capture: !!ffmpegPath, playback: !!ffplayPath };
+  if (ffmpegPath) out.ffmpegPath = ffmpegPath;
+  if (ffplayPath) out.ffplayPath = ffplayPath;
+  if (!ffmpegPath || !ffplayPath) {
+    const missing = [ffmpegPath ? "" : "ffmpeg", ffplayPath ? "" : "ffplay"].filter(Boolean).join(" + ");
+    out.reason = `${missing} not found on PATH (voice needs ffmpeg; brew/apt install ffmpeg)`;
+  }
+  return out;
+}
+function which(bin) {
+  const exts = process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+  for (const dir of (process.env.PATH ?? "").split(path2.delimiter).filter(Boolean)) {
+    for (const ext of exts) {
+      const candidate = path2.join(dir, bin + ext);
+      try {
+        if (!fs2.existsSync(candidate)) continue;
+        fs2.accessSync(candidate, fs2.constants.X_OK);
+        if (fs2.statSync(candidate).isFile()) return candidate;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function captureArgs(platform, device) {
+  const base = ["-hide_banner", "-loglevel", "error"];
+  const output = ["-ac", "1", "-ar", String(SAMPLE_RATE), "-f", "s16le", "-"];
+  if (platform === "darwin") return [...base, "-f", "avfoundation", "-i", ":" + (device ?? "default"), ...output];
+  if (platform === "win32") return [...base, "-f", "dshow", "-i", "audio=" + (device ?? "default"), ...output];
+  return [...base, "-f", "alsa", "-i", device ?? "default", ...output];
+}
+function chunkPcm(buf, chunkBytes) {
+  if (!Number.isInteger(chunkBytes) || chunkBytes <= 0) throw new RangeError("chunkBytes must be a positive integer");
+  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+  const out = [];
+  for (let i = 0; i < b.length; i += chunkBytes) out.push(b.subarray(i, i + chunkBytes).toString("base64"));
+  return out;
+}
+var VoiceCapture = class {
+  constructor(tools) {
+    this.tools = tools;
+  }
+  tools;
+  session = null;
+  get active() {
+    return this.session !== null;
+  }
+  /** Spawn ffmpeg mic->PCM and stream ~40ms base64 chunks to onChunk.
+   *  No-op while a capture is already active. */
+  start(opts) {
+    if (this.session) return;
+    if (!this.tools.capture || !this.tools.ffmpegPath) {
+      const why = this.tools.reason ?? "ffmpeg not found on PATH";
+      queueMicrotask(() => opts.onError(why));
+      return;
+    }
+    this.session = this.spawnSession(opts, captureArgs(process.platform, opts.device), "primary");
+  }
+  /** Flush the sub-chunk remainder, then SIGINT -> SIGKILL after 300ms. */
+  stop() {
+    const s = this.session;
+    if (!s) return;
+    this.session = null;
+    s.stopped = true;
+    if (s.buf.length) {
+      s.onChunk(s.buf.toString("base64"));
+      s.buf = Buffer.alloc(0);
+    }
+    try {
+      s.child.kill("SIGINT");
+    } catch {
+    }
+    const t = setTimeout(() => {
+      try {
+        s.child.kill("SIGKILL");
+      } catch {
+      }
+    }, KILL_GRACE_MS);
+    t.unref();
+  }
+  spawnSession(opts, args, backend) {
+    let child;
+    try {
+      child = spawn(this.tools.ffmpegPath, args, { stdio: ["ignore", "pipe", "pipe"] });
+    } catch (e) {
+      vlog(Date.now(), "capture", "ffmpeg spawn threw", { backend, err: errMsg(e) });
+      queueMicrotask(() => opts.onError("mic capture failed to start: " + errMsg(e)));
+      return null;
+    }
+    vlog(Date.now(), "capture", "ffmpeg spawned", { backend, device: opts.device ?? "default", args: args.join(" ") });
+    const s = { child, onChunk: opts.onChunk, buf: Buffer.alloc(0), stderrTail: "", produced: false, stopped: false };
+    child.stdout?.on("data", (chunk) => {
+      if (s.stopped) return;
+      if (!s.produced) vlog(Date.now(), "capture", "first audio bytes from mic", { backend, bytes: chunk.length });
+      s.produced = true;
+      s.buf = s.buf.length ? Buffer.concat([s.buf, chunk]) : chunk;
+      const whole = Math.floor(s.buf.length / CHUNK_BYTES) * CHUNK_BYTES;
+      if (whole === 0) return;
+      for (const b64 of chunkPcm(s.buf.subarray(0, whole), CHUNK_BYTES)) opts.onChunk(b64);
+      s.buf = s.buf.subarray(whole);
+    });
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (c) => {
+      s.stderrTail = (s.stderrTail + c).slice(-STDERR_TAIL);
+    });
+    child.on("error", (e) => {
+      if (s.stopped || this.session !== s) return;
+      this.session = null;
+      vlog(Date.now(), "capture", "ffmpeg error", { backend, code: e.code, produced: s.produced, stderr: s.stderrTail.trim() });
+      opts.onError(e.code === "ENOENT" ? "ffmpeg not found" : "mic capture error: " + errMsg(e));
+    });
+    child.on("close", (code) => {
+      if (s.stopped || this.session !== s) return;
+      vlog(Date.now(), "capture", "ffmpeg exited", { backend, code, producedAudio: s.produced, stderr: s.stderrTail.trim() });
+      if (backend === "primary" && process.platform === "linux" && !s.produced && code !== 0) {
+        vlog(Date.now(), "capture", "alsa failed, retrying on pulse");
+        const pulse = captureArgs("linux", opts.device).map((a) => a === "alsa" ? "pulse" : a);
+        this.session = this.spawnSession(opts, pulse, "pulse");
+        return;
+      }
+      this.session = null;
+      const tail = s.stderrTail.trim();
+      opts.onError(code === 0 ? "mic capture ended unexpectedly" : "mic capture failed: " + (tail || `ffmpeg exited with code ${code}`));
+    });
+    return s;
+  }
+};
+var VoicePlayback = class {
+  constructor(tools) {
+    this.tools = tools;
+  }
+  tools;
+  players = /* @__PURE__ */ new Map();
+  /** ids with an active player */
+  get speakers() {
+    return [...this.players.keys()];
+  }
+  /** Feed a received chunk; lazily spawns one ffplay per speaker. Chunks
+   *  are dropped silently when playback is unavailable, the speaker cap
+   *  is hit, or a player cannot be (re)spawned. */
+  feed(speakerId, b64) {
+    if (!this.tools.playback || !this.tools.ffplayPath) return;
+    const bytes = Buffer.from(b64, "base64");
+    if (bytes.length === 0) return;
+    let p = this.players.get(speakerId);
+    if (p && !p.alive) {
+      this.reap(speakerId, p);
+      p = void 0;
+    }
+    if (!p) {
+      if (this.players.size >= MAX_PLAYERS) return;
+      const spawned = this.spawnPlayer(speakerId);
+      if (!spawned) return;
+      p = spawned;
+    }
+    if (!p.flowing) {
+      p.pre.push(bytes);
+      if (p.pre.reduce((n, b) => n + b.length, 0) >= PREBUFFER_BYTES) {
+        const cushion = Buffer.concat(p.pre);
+        p.pre = [];
+        p.flowing = true;
+        const np2 = this.writeOrRespawn(speakerId, p, cushion);
+        if (np2) this.touch(speakerId, np2);
+      } else {
+        this.touch(speakerId, p);
+      }
+      return;
+    }
+    const np = this.writeOrRespawn(speakerId, p, bytes);
+    if (np) this.touch(speakerId, np);
+  }
+  /** Write to a player; on EPIPE (it died) respawn once and write there. Returns
+   *  the live player, or null if it couldn't be (re)spawned. */
+  writeOrRespawn(speakerId, p, buf) {
+    if (this.write(p, buf)) return p;
+    this.reap(speakerId, p);
+    const fresh = this.players.size < MAX_PLAYERS ? this.spawnPlayer(speakerId) : null;
+    if (!fresh || !this.write(fresh, buf)) return null;
+    fresh.flowing = true;
+    return fresh;
+  }
+  /** Graceful close for one speaker (voiceStop): end stdin so ffplay drains
+   *  its buffered audio, then a SIGKILL backstop after 2s (we dropped -autoexit,
+   *  so the backstop is what actually reaps the idle player). */
+  end(speakerId) {
+    const p = this.players.get(speakerId);
+    if (!p) return;
+    this.players.delete(speakerId);
+    if (p.idleTimer) {
+      clearTimeout(p.idleTimer);
+      p.idleTimer = null;
+    }
+    try {
+      p.child.stdin?.end();
+    } catch {
+    }
+    const t = setTimeout(() => {
+      try {
+        p.child.kill("SIGKILL");
+      } catch {
+      }
+    }, DRAIN_KILL_MS);
+    t.unref();
+  }
+  /** Hard cleanup on quit: kill every player immediately. */
+  stopAll() {
+    for (const [, p] of this.players) {
+      if (p.idleTimer) {
+        clearTimeout(p.idleTimer);
+        p.idleTimer = null;
+      }
+      p.alive = false;
+      try {
+        p.child.kill("SIGKILL");
+      } catch {
+      }
+    }
+    this.players.clear();
+  }
+  spawnPlayer(speakerId) {
+    const args = playbackArgs(this.tools.ffplayPath);
+    let child;
+    try {
+      child = spawn(this.tools.ffplayPath, args, { stdio: ["pipe", "ignore", "pipe"] });
+    } catch (e) {
+      vlog(Date.now(), "playback", "ffplay spawn threw", { speaker: speakerId, err: errMsg(e) });
+      return null;
+    }
+    vlog(Date.now(), "playback", "ffplay spawned", { speaker: speakerId, args: args.join(" ") });
+    const p = { child, alive: true, idleTimer: null, pre: [], flowing: false };
+    let stderrTail = "";
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (c) => {
+      stderrTail = (stderrTail + c).slice(-STDERR_TAIL);
+    });
+    child.stdin?.on("error", () => {
+      p.alive = false;
+    });
+    child.on("error", (e) => {
+      p.alive = false;
+      vlog(Date.now(), "playback", "ffplay error", { speaker: speakerId, code: e.code, msg: errMsg(e) });
+      if (this.players.get(speakerId) === p) this.reap(speakerId, p);
+    });
+    child.on("close", (code) => {
+      p.alive = false;
+      vlog(Date.now(), "playback", "ffplay exited", { speaker: speakerId, code, stderr: stderrTail.trim() });
+      if (this.players.get(speakerId) === p) {
+        if (p.idleTimer) {
+          clearTimeout(p.idleTimer);
+          p.idleTimer = null;
+        }
+        this.players.delete(speakerId);
+      }
+    });
+    this.players.set(speakerId, p);
+    return p;
+  }
+  write(p, bytes) {
+    const sin = p.child.stdin;
+    if (!p.alive || !sin || sin.destroyed || !sin.writable) return false;
+    try {
+      sin.write(bytes);
+      return true;
+    } catch {
+      p.alive = false;
+      return false;
+    }
+  }
+  touch(speakerId, p) {
+    if (p.idleTimer) clearTimeout(p.idleTimer);
+    p.idleTimer = setTimeout(() => this.end(speakerId), SPEAKER_IDLE_MS);
+    p.idleTimer.unref();
+  }
+  reap(speakerId, p) {
+    if (p.idleTimer) {
+      clearTimeout(p.idleTimer);
+      p.idleTimer = null;
+    }
+    p.alive = false;
+    try {
+      p.child.kill("SIGKILL");
+    } catch {
+    }
+    if (this.players.get(speakerId) === p) this.players.delete(speakerId);
+  }
+};
+function listMicDevices() {
+  try {
+    if (process.platform === "darwin") {
+      const text = runForOutput(["-hide_banner", "-f", "avfoundation", "-list_devices", "true", "-i", ""]);
+      const out = [];
+      let inAudio = false;
+      for (const line of text.split("\n")) {
+        if (/audio devices/i.test(line)) {
+          inAudio = true;
+          continue;
+        }
+        if (/video devices/i.test(line)) {
+          inAudio = false;
+          continue;
+        }
+        if (!inAudio) continue;
+        const m = line.match(/\[(\d+)\]\s+(.+?)\s*$/);
+        if (m) out.push({ index: m[1], name: m[2] });
+      }
+      return out;
+    }
+    if (process.platform === "linux") {
+      const text = runForOutput(["-hide_banner", "-sources", "pulse"]);
+      const out = [];
+      for (const line of text.split("\n")) {
+        if (/auto-detected/i.test(line)) continue;
+        const m = line.match(/^\s*\*?\s*(\S+)\s+\[(.+)\]\s*$/);
+        if (m) out.push({ index: m[1], name: m[2] });
+      }
+      return out;
+    }
+    if (process.platform === "win32") {
+      const text = runForOutput(["-hide_banner", "-list_devices", "true", "-f", "dshow", "-i", "dummy"]);
+      const out = [];
+      for (const line of text.split("\n")) {
+        const m = line.match(/"(.+)"\s+\(audio\)/);
+        if (m) out.push({ index: m[1], name: m[1] });
+      }
+      return out;
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+function runForOutput(args) {
+  const res = spawnSync("ffmpeg", args, { encoding: "utf8", timeout: 5e3 });
+  return (res.stderr ?? "") + (res.stdout ?? "");
+}
+function errMsg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+
+// src/geo.ts
+function localTz() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "";
+  } catch {
+    return "";
+  }
+}
+var TZ = {
+  // north america
+  "America/New_York": [40.7, -74],
+  "America/Detroit": [42.3, -83],
+  "America/Toronto": [43.7, -79.4],
+  "America/Chicago": [41.9, -87.6],
+  "America/Winnipeg": [49.9, -97.1],
+  "America/Mexico_City": [19.4, -99.1],
+  "America/Denver": [39.7, -104.99],
+  "America/Edmonton": [53.5, -113.5],
+  "America/Phoenix": [33.4, -112.1],
+  "America/Los_Angeles": [34.05, -118.24],
+  "America/Vancouver": [49.3, -123.1],
+  "America/Anchorage": [61.2, -149.9],
+  "Pacific/Honolulu": [21.3, -157.8],
+  "America/Halifax": [44.6, -63.6],
+  "America/St_Johns": [47.6, -52.7],
+  // south + central america
+  "America/Sao_Paulo": [-23.5, -46.6],
+  "America/Argentina/Buenos_Aires": [-34.6, -58.4],
+  "America/Santiago": [-33.5, -70.7],
+  "America/Lima": [-12, -77],
+  "America/Bogota": [4.7, -74.1],
+  "America/Caracas": [10.5, -66.9],
+  "America/Guatemala": [14.6, -90.5],
+  // europe
+  "Europe/London": [51.5, -0.13],
+  "Europe/Dublin": [53.3, -6.3],
+  "Europe/Lisbon": [38.7, -9.1],
+  "Europe/Madrid": [40.4, -3.7],
+  "Europe/Paris": [48.86, 2.35],
+  "Europe/Amsterdam": [52.4, 4.9],
+  "Europe/Brussels": [50.8, 4.4],
+  "Europe/Zurich": [47.4, 8.5],
+  "Europe/Berlin": [52.5, 13.4],
+  "Europe/Rome": [41.9, 12.5],
+  "Europe/Vienna": [48.2, 16.4],
+  "Europe/Prague": [50.1, 14.4],
+  "Europe/Copenhagen": [55.7, 12.6],
+  "Europe/Stockholm": [59.3, 18.1],
+  "Europe/Oslo": [59.9, 10.7],
+  "Europe/Warsaw": [52.2, 21],
+  "Europe/Athens": [38, 23.7],
+  "Europe/Bucharest": [44.4, 26.1],
+  "Europe/Kyiv": [50.5, 30.5],
+  "Europe/Kiev": [50.5, 30.5],
+  "Europe/Istanbul": [41, 28.98],
+  "Europe/Moscow": [55.75, 37.6],
+  "Europe/Helsinki": [60.2, 24.9],
+  // africa + middle east
+  "Africa/Casablanca": [33.6, -7.6],
+  "Africa/Lagos": [6.5, 3.4],
+  "Africa/Cairo": [30, 31.2],
+  "Africa/Nairobi": [-1.3, 36.8],
+  "Africa/Johannesburg": [-26.2, 28],
+  "Asia/Jerusalem": [31.8, 35.2],
+  "Asia/Dubai": [25.2, 55.3],
+  "Asia/Tehran": [35.7, 51.4],
+  "Asia/Riyadh": [24.7, 46.7],
+  "Asia/Baghdad": [33.3, 44.4],
+  // asia
+  "Asia/Karachi": [24.9, 67],
+  "Asia/Kolkata": [22.6, 88.4],
+  "Asia/Calcutta": [22.6, 88.4],
+  "Asia/Colombo": [6.9, 79.9],
+  "Asia/Dhaka": [23.8, 90.4],
+  "Asia/Bangkok": [13.8, 100.5],
+  "Asia/Jakarta": [-6.2, 106.8],
+  "Asia/Singapore": [1.35, 103.8],
+  "Asia/Kuala_Lumpur": [3.1, 101.7],
+  "Asia/Manila": [14.6, 121],
+  "Asia/Hong_Kong": [22.3, 114.2],
+  "Asia/Shanghai": [31.2, 121.5],
+  "Asia/Taipei": [25, 121.5],
+  "Asia/Seoul": [37.6, 127],
+  "Asia/Tokyo": [35.7, 139.7],
+  // oceania
+  "Australia/Perth": [-31.95, 115.9],
+  "Australia/Adelaide": [-34.9, 138.6],
+  "Australia/Brisbane": [-27.5, 153],
+  "Australia/Sydney": [-33.87, 151.2],
+  "Australia/Melbourne": [-37.8, 145],
+  "Pacific/Auckland": [-36.85, 174.76]
+};
+var REGION = {
+  America: [15, -90],
+  Europe: [50, 15],
+  Africa: [3, 22],
+  Asia: [35, 95],
+  Australia: [-25, 135],
+  Pacific: [-10, -160],
+  Atlantic: [35, -35],
+  Indian: [-15, 75],
+  Antarctica: [-80, 0]
+};
+function tzToCoords(tz) {
+  if (!tz) return null;
+  const exact = TZ[tz];
+  if (exact) return { lat: exact[0], lon: exact[1] };
+  const region = REGION[tz.split("/")[0]];
+  if (region) return { lat: region[0], lon: region[1] };
+  return null;
+}
+function tzCity(tz) {
+  if (!tz) return "";
+  const parts = tz.split("/");
+  return (parts[parts.length - 1] || tz).replace(/_/g, " ");
+}
+
+export {
+  vlog,
+  vlogSession,
+  voiceLogPath,
+  detectVoiceTools,
+  VoiceCapture,
+  VoicePlayback,
+  listMicDevices,
+  localTz,
+  tzToCoords,
+  tzCity
+};

package/dist/chunks/{chunk-AY3UXM6A.js → chunk-TW4QNNNT.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/protocol.ts
-var VERSION = true ? "3.1.1" : "3.0.2";
+var VERSION = true ? "3.3.0" : "3.3.0";
 var PROTO = 3;
 var PORT = 8787;
 var DEFAULT_SERVER = "wss://accelr8-canvas.patonchain.workers.dev";