accelr8 3.0.0 → 3.0.2

package/dist/chunks/{chunk-SF6NNSYZ.js → chunk-WRSSNAIF.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/protocol.ts
-var VERSION = "3.0.0";
+var VERSION = true ? "3.0.2" : "3.0.2";
 var PROTO = 3;
 var PORT = 8787;
 var DEFAULT_SERVER = "wss://accelr8-canvas.patonchain.workers.dev";
@@ -36,7 +36,11 @@ var LIMITS = {
   agentQueueCap: 5,
   agentMaxDepth: 3,
   agentBudgetPerTrigger: 5,
-  agentRepeatPerChain: 2
+  agentRepeatPerChain: 2,
+  voiceFramesPerSec: 50,
+  // ~25/s real, 2x headroom; exempt from framesPerWindow
+  voiceFrameMaxB64: 4096
+  // a 40ms s16le mono chunk is ~1.7KB base64; cap slack
 };
 var DEFAULT_ACCESS = { mode: "owner", users: [] };
 function encode(msg) {

package/dist/chunks/{client-7BVK2DEW.js → client-W4563KDL.js}

@@ -7,7 +7,7 @@ import {
   VERSION,
   decode,
   encode
-} from "./chunk-SF6NNSYZ.js";
+} from "./chunk-WRSSNAIF.js";
 import {
   DEFAULT_MODEL,
   addAccount,
@@ -25,7 +25,7 @@ import {
 // src/client.ts
 import tk from "terminal-kit";
 import { WebSocket } from "ws";
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -1173,6 +1173,295 @@ function microLine(w, engine, frame2, info) {
   return clampTo(tiny, Math.max(0, w));
 }
 
+// src/voice.ts
+import { spawn, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+var SAMPLE_RATE = 16e3;
+var CHUNK_BYTES = 1280;
+var KILL_GRACE_MS = 300;
+var SPEAKER_IDLE_MS = 2e3;
+var DRAIN_KILL_MS = 2e3;
+var MAX_PLAYERS = 8;
+var STDERR_TAIL = 400;
+var VERIFY_MIN_BYTES = SAMPLE_RATE * 2 / 10;
+var PLAYBACK_ARGS = [
+  "-hide_banner",
+  "-loglevel",
+  "error",
+  "-nodisp",
+  "-fflags",
+  "nobuffer",
+  "-flags",
+  "low_delay",
+  "-f",
+  "s16le",
+  "-ar",
+  String(SAMPLE_RATE),
+  "-ch_layout",
+  "mono",
+  "-i",
+  "-"
+];
+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(path.delimiter).filter(Boolean)) {
+    for (const ext of exts) {
+      const candidate = path.join(dir, bin + ext);
+      try {
+        if (!fs.existsSync(candidate)) continue;
+        fs.accessSync(candidate, fs.constants.X_OK);
+        if (fs.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) {
+      queueMicrotask(() => opts.onError("mic capture failed to start: " + errMsg(e)));
+      return null;
+    }
+    const s = { child, onChunk: opts.onChunk, buf: Buffer.alloc(0), stderrTail: "", produced: false, stopped: false };
+    child.stdout?.on("data", (chunk) => {
+      if (s.stopped) return;
+      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;
+      opts.onError(e.code === "ENOENT" ? "ffmpeg not found" : "mic capture error: " + errMsg(e));
+    });
+    child.on("close", (code) => {
+      if (s.stopped || this.session !== s) return;
+      if (backend === "primary" && process.platform === "linux" && !s.produced && code !== 0) {
+        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 (!this.write(p, bytes)) {
+      this.reap(speakerId, p);
+      const fresh = this.players.size < MAX_PLAYERS ? this.spawnPlayer(speakerId) : null;
+      if (!fresh || !this.write(fresh, bytes)) return;
+      p = fresh;
+    }
+    this.touch(speakerId, p);
+  }
+  /** 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) {
+    let child;
+    try {
+      child = spawn(this.tools.ffplayPath, PLAYBACK_ARGS, { stdio: ["pipe", "ignore", "ignore"] });
+    } catch {
+      return null;
+    }
+    const p = { child, alive: true, idleTimer: null };
+    child.stdin?.on("error", () => {
+      p.alive = false;
+    });
+    child.on("error", () => {
+      p.alive = false;
+      if (this.players.get(speakerId) === p) this.reap(speakerId, p);
+    });
+    child.on("close", () => {
+      p.alive = false;
+      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 errMsg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+
 // src/client.ts
 var term = tk.terminal;
 var ScreenBuffer = tk.ScreenBuffer;
@@ -1223,26 +1512,135 @@ var overlay = null;
 var accessAgentId = null;
 var overlayFocus = 0;
 var updateInfo = null;
-var updating = null;
-var cancelUpdate = null;
+var task = null;
+var cancelTask = null;
 function startUpdate() {
-  if (updating && !updating.done) return;
-  updating = { line: "starting npm\u2026", message: "" };
+  if (task && task.phase === "running") return;
+  task = { title: "updating accelr8", phase: "running", line: "starting npm\u2026", okLabel: "quit now \xB7 enter", onOk: () => shutdown() };
   import("./update-UEPNGB6Y.js").then(({ runUpdate }) => {
-    cancelUpdate = runUpdate({
+    cancelTask = runUpdate({
       onLine: (l) => {
-        if (updating) updating.line = l.slice(0, 120);
+        if (task) task.line = l.slice(0, 120);
       },
       onDone: (ok, message) => {
-        updating = { line: "", done: ok ? "ok" : "fail", message };
-        cancelUpdate = null;
+        if (task) {
+          task.phase = "done";
+          task.ok = ok;
+          task.line = message;
+        }
+        cancelTask = null;
         if (ok) updateInfo = null;
       }
     });
   }).catch(() => {
-    updating = { line: "", done: "fail", message: "could not load the updater \xB7 npm i -g accelr8@latest" };
+    if (task) {
+      task.phase = "done";
+      task.ok = false;
+      task.line = "could not load the updater \xB7 npm i -g accelr8@latest";
+    }
+  });
+}
+function startVoiceInstall() {
+  import("./install-DL5WLVXN.js").then(({ ffmpegInstallPlan, runCommand }) => {
+    const plan = ffmpegInstallPlan();
+    if (!plan.auto) {
+      state.status = `voice needs ffmpeg \xB7 ${plan.manual}`;
+      return;
+    }
+    const auto = plan.auto;
+    task = {
+      title: "enable voice",
+      phase: "confirm",
+      line: `voice needs ffmpeg \xB7 ${auto.label} \xB7 press enter`,
+      run: () => {
+        if (!task) return;
+        task.phase = "running";
+        task.line = "installing ffmpeg\u2026";
+        cancelTask = runCommand(auto.cmd, auto.args, {
+          onLine: (l) => {
+            if (task) task.line = l.slice(0, 120);
+          },
+          onDone: (ok, message) => {
+            if (task) {
+              task.phase = "done";
+              task.ok = ok;
+              task.line = ok ? "ffmpeg ready \xB7 voice is on" : message + " \xB7 " + auto.label;
+              task.okLabel = ok ? "start voice \xB7 enter" : void 0;
+            }
+            cancelTask = null;
+          }
+        });
+      },
+      onOk: () => {
+        voiceTools = null;
+        task = null;
+        toggleVoice();
+      }
+      // re-detect + join
+    };
+  }).catch(() => {
+    state.status = "could not load the installer";
   });
 }
+var voiceTools = null;
+var voiceOn = false;
+var voiceTransmit = false;
+var voiceCapture = null;
+var voicePlayback = null;
+function toggleVoice() {
+  if (voiceOn) return leaveVoice();
+  if (!state.project) {
+    state.status = "join a project first";
+    return;
+  }
+  voiceTools = voiceTools ?? detectVoiceTools();
+  if (!voiceTools.capture && !voiceTools.playback) {
+    startVoiceInstall();
+    return;
+  }
+  voicePlayback = new VoicePlayback(voiceTools);
+  voiceCapture = new VoiceCapture(voiceTools);
+  voiceOn = true;
+  voiceTransmit = false;
+  sendMsg({ t: "voiceJoin" });
+  state.status = voiceTools.capture ? "voice on \xB7 /talk (or ctrl-g) to speak" : "voice on \xB7 listen only (no mic found)";
+}
+function leaveVoice() {
+  if (!voiceOn) return;
+  voiceCapture?.stop();
+  voicePlayback?.stopAll();
+  voiceCapture = null;
+  voicePlayback = null;
+  voiceOn = false;
+  voiceTransmit = false;
+  state.voicePeers = [];
+  sendMsg({ t: "voiceLeave" });
+  state.status = "voice off";
+}
+function toggleTalk() {
+  if (!voiceOn || !voiceCapture) return;
+  if (!voiceTools?.capture) {
+    state.status = "no mic \xB7 install ffmpeg to talk";
+    return;
+  }
+  if (voiceTransmit) {
+    voiceCapture.stop();
+    voiceTransmit = false;
+    state.status = "muted \xB7 /talk (or ctrl-g) to speak";
+  } else {
+    voiceTransmit = true;
+    state.status = "\u25CF live \xB7 /mute (or ctrl-g) to stop";
+    voiceCapture.start({
+      onChunk: (b64) => {
+        if (voiceTransmit) sendMsg({ t: "voiceFrame", data: b64 });
+      },
+      onError: (m) => {
+        voiceTransmit = false;
+        state.status = "mic error \xB7 " + m.slice(0, 44);
+      }
+    });
+  }
+}
 function openHelp() {
   overlay = "help";
   overlayFocus = 0;
@@ -1253,6 +1651,7 @@ function openSettings() {
 }
 function goHome() {
   if (state.project) {
+    if (voiceOn) leaveVoice();
     overlay = null;
     state.screen = "home";
     sendMsg({ t: "tab", tab: "home" });
@@ -1270,6 +1669,7 @@ var state = {
   sessions: [],
   agents: [],
   secrets: [],
+  voicePeers: [],
   status: "",
   modal: null
 };
@@ -1664,6 +2064,12 @@ function handleServer(msg) {
     case "secrets":
       state.secrets = Array.isArray(msg.list) ? msg.list : [];
       break;
+    case "voice":
+      state.voicePeers = Array.isArray(msg.peers) ? msg.peers : [];
+      break;
+    case "voiceFrame":
+      if (voiceOn) voicePlayback?.feed(msg.sid, msg.data);
+      break;
     case "error": {
       if (msg.code === "chatRate" || msg.code === "msgTooLarge") {
         const failed = msg.ref ? chatLog.failOptimistic(msg.ref) : null;
@@ -1851,6 +2257,9 @@ function __curTheme() {
 function __setUpdate(latest, current = "3.0.0") {
   updateInfo = latest ? { latest, current } : null;
 }
+function __taskDemo(phase, ok = true) {
+  task = { title: "enable voice", phase, ok, line: phase === "confirm" ? "voice needs ffmpeg \xB7 brew install ffmpeg \xB7 press enter" : phase === "running" ? "installing ffmpeg\u2026" : ok ? "ffmpeg ready \xB7 voice is on" : "brew exited 1 \xB7 brew install ffmpeg", okLabel: "start voice \xB7 enter" };
+}
 function __closeOverlay() {
   overlay = null;
 }
@@ -1936,28 +2345,36 @@ function render() {
     overlayFocus = clickables.length ? Math.max(0, Math.min(overlayFocus, clickables.length - 1)) : 0;
   }
   if (state.modal && bigEnough) renderModal();
-  if (updating && bigEnough) renderUpdating();
+  if (task && bigEnough) renderTask();
   if (screen.dst) screen.draw({ delta: true });
 }
-function renderUpdating() {
+function renderTask() {
   clickables = [];
   const w = W(), h = H();
   const bw = Math.min(66, w - 6), bh = 7;
   const x0 = Math.floor((w - bw) / 2), y0 = Math.floor((h - bh) / 2);
   for (let yy = y0; yy < y0 + bh; yy++) puts(x0, yy, " ".repeat(bw), { bgColor: C.panel });
-  box(x0, y0, x0 + bw - 1, y0 + bh - 1, { color: C.accent, bgColor: C.panel }, "updating accelr8");
-  const u = updating;
-  if (!u.done) {
-    puts(x0 + 2, y0 + 2, `${SPINNER[frame % SPINNER.length]} installing accelr8@latest\u2026`, { color: C.bright, bgColor: C.panel, bold: true });
-    puts(x0 + 2, y0 + 4, ("\xB7 " + u.line).slice(0, bw - 4), { color: C.dim, bgColor: C.panel });
-  } else if (u.done === "ok") {
-    puts(x0 + 2, y0 + 2, "\u2713 " + u.message, { color: C.good, bgColor: C.panel, bold: true });
-    button(x0 + 2, y0 + 4, " quit now \xB7 enter ", { bgColor: C.good, color: onFill(C.good), bold: true }, () => shutdown());
-    puts(x0 + 22, y0 + 4, "then run: accelr8", { color: C.dim, bgColor: C.panel });
+  box(x0, y0, x0 + bw - 1, y0 + bh - 1, { color: C.accent, bgColor: C.panel }, task.title);
+  const t = task;
+  if (t.phase === "confirm") {
+    puts(x0 + 2, y0 + 2, t.line.slice(0, bw - 4), { color: C.bright, bgColor: C.panel, bold: true });
+    button(x0 + 2, y0 + 4, " install \xB7 enter ", { bgColor: C.accent, color: onFill(C.accent), bold: true }, () => t.run?.());
+    button(x0 + 20, y0 + 4, " not now \xB7 esc ", { bgColor: C.tabOff, color: C.text }, () => {
+      task = null;
+    });
+  } else if (t.phase === "running") {
+    puts(x0 + 2, y0 + 2, `${SPINNER[frame % SPINNER.length]} ${t.title}\u2026`, { color: C.bright, bgColor: C.panel, bold: true });
+    puts(x0 + 2, y0 + 4, ("\xB7 " + t.line).slice(0, bw - 4), { color: C.dim, bgColor: C.panel });
+  } else if (t.ok) {
+    puts(x0 + 2, y0 + 2, "\u2713 " + t.line.slice(0, bw - 6), { color: C.good, bgColor: C.panel, bold: true });
+    if (t.okLabel) button(x0 + 2, y0 + 4, ` ${t.okLabel} `, { bgColor: C.good, color: onFill(C.good), bold: true }, () => t.onOk?.());
+    else button(x0 + 2, y0 + 4, " close \xB7 enter ", { bgColor: C.good, color: onFill(C.good), bold: true }, () => {
+      task = null;
+    });
   } else {
-    puts(x0 + 2, y0 + 2, "\u2715 " + u.message.slice(0, bw - 6), { color: C.danger, bgColor: C.panel, bold: true });
+    puts(x0 + 2, y0 + 2, "\u2715 " + t.line.slice(0, bw - 6), { color: C.danger, bgColor: C.panel, bold: true });
     button(x0 + 2, y0 + 4, " close \xB7 esc ", { bgColor: C.tabOff, color: C.text }, () => {
-      updating = null;
+      task = null;
     });
   }
 }
@@ -2239,7 +2656,7 @@ function renderHome(rung) {
     }
     y += 1;
   }
-  if (updateInfo && !updating) {
+  if (updateInfo && !task) {
     puts(2, y, "\u21BB", { color: C.warn, bold: true });
     const w2 = W();
     const label = ` update to v${updateInfo.latest} \xB7 press enter `;
@@ -2297,7 +2714,12 @@ function renderStatusBar(rung) {
   puts(0, sy, " ".repeat(w), { bgColor: C.panel });
   const agentBit = state.agents.length ? ` \xB7 \u2726${state.agents.length} agents` : "";
   const left = state.project ? ` ${state.project.name} \xB7 ${state.project.code} \xB7 ${onlineUserIds().size} online${agentBit} ` : " no project open ";
-  puts(0, sy, left.slice(0, w - 24), { bgColor: C.panel, color: C.dim });
+  const drawn = left.slice(0, w - 24);
+  puts(0, sy, drawn, { bgColor: C.panel, color: C.dim });
+  if (voiceOn) {
+    const label = voiceTransmit ? " \u25CF live \xB7 /mute" : ` \u25CB voice ${state.voicePeers.length} \xB7 /talk`;
+    if (drawn.length + label.length < w - 24) puts(drawn.length, sy, label, { bgColor: C.panel, color: voiceTransmit ? C.good : C.accent, bold: voiceTransmit });
+  }
   const hint = state.modal ? "[enter] ok \xB7 [esc] cancel " : "[tab] tabs \xB7 [^C] quit ";
   puts(w - hint.length, sy, hint, { bgColor: C.panel, color: C.dim });
   if (state.status) {
@@ -2954,7 +3376,7 @@ function copyToClipboard(text, tools) {
     return;
   }
   try {
-    const p = spawn(tool, args, { stdio: ["pipe", "ignore", "ignore"] });
+    const p = spawn2(tool, args, { stdio: ["pipe", "ignore", "ignore"] });
     p.on("error", () => copyToClipboard(text, candidatesList.slice(1)));
     p.on("close", (code) => {
       state.status = code === 0 ? "copied join command" : "copy failed";
@@ -2976,7 +3398,7 @@ function onMouse(name, data) {
     return;
   }
   if (state.modal) return;
-  if (updating) {
+  if (task) {
     if (name === "MOUSE_LEFT_BUTTON_PRESSED") {
       for (const r of clickables) if (mx >= r.x0 && mx <= r.x1 && my >= r.y0 && my <= r.y1) {
         r.action();
@@ -3092,6 +3514,10 @@ function slashCommand(text) {
     ghostsOff = cmd.endsWith("off");
     state.status = ghostsOff ? "draft broadcasting off" : "draft broadcasting on";
     draftDirty = true;
+  } else if (cmd === "/voice") {
+    toggleVoice();
+  } else if (cmd === "/talk" || cmd === "/mute") {
+    toggleTalk();
   } else {
     state.status = `unknown command: ${cmd.split(" ")[0]}`;
   }
@@ -3118,24 +3544,27 @@ function sendChat() {
 }
 function onKey(name) {
   if (name === "CTRL_C") return shutdown();
+  if ((name === "CTRL_G" || name === "CTRL_ALT_G") && voiceOn) return toggleTalk();
   if (boot) return skipBoot();
   const rung = rungFor(W(), H());
   if (rung === "micro" || rung === "orb") return;
   const paused = rung === "ticker";
-  if (updating && !paused) {
-    if (!updating.done) {
-      if (name === "ESCAPE") {
-        cancelUpdate?.();
-        updating = null;
-      }
+  if (task && !paused) {
+    const enter = name === "ENTER" || name === "KP_ENTER";
+    if (task.phase === "confirm") {
+      if (enter) task.run?.();
+      else if (name === "ESCAPE") task = null;
       return;
     }
-    if (updating.done === "ok") {
-      if (name === "ENTER" || name === "KP_ENTER" || name === "q") return shutdown();
-      if (name === "ESCAPE") updating = null;
+    if (task.phase === "running") {
+      if (name === "ESCAPE") {
+        cancelTask?.();
+        task = null;
+      }
       return;
     }
-    if (name === "ESCAPE" || name === "ENTER" || name === "KP_ENTER") updating = null;
+    if (enter && task.ok && task.onOk) return task.onOk();
+    if (enter || name === "ESCAPE") task = null;
     return;
   }
   if (state.modal && !paused) {
@@ -3358,6 +3787,11 @@ function restoreTerminal() {
 }
 function shutdown() {
   restoreTerminal();
+  try {
+    voiceCapture?.stop();
+    voicePlayback?.stopAll();
+  } catch {
+  }
   for (const h of runningExec.values()) {
     try {
       h.abort();
@@ -3440,6 +3874,7 @@ export {
   __setMySid,
   __setNav,
   __setUpdate,
+  __taskDemo,
   chatLog,
   cursors,
   editor,

package/dist/chunks/install-DL5WLVXN.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+// src/install.ts
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+function which(bin) {
+  const exts = process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+  for (const dir of (process.env.PATH ?? "").split(path.delimiter).filter(Boolean)) {
+    for (const ext of exts) {
+      const p = path.join(dir, bin + ext);
+      try {
+        fs.accessSync(p, fs.constants.X_OK);
+        if (fs.statSync(p).isFile()) return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function ffmpegInstallPlan(platform = process.platform) {
+  if (platform === "darwin") {
+    if (which("brew")) return { auto: { cmd: "brew", args: ["install", "ffmpeg"], label: "brew install ffmpeg" }, manual: "brew install ffmpeg" };
+    return { manual: "install Homebrew from brew.sh, then: brew install ffmpeg", note: "Homebrew not found" };
+  }
+  if (platform === "win32") {
+    if (which("winget")) return { auto: { cmd: "winget", args: ["install", "--silent", "--accept-package-agreements", "--accept-source-agreements", "Gyan.FFmpeg"], label: "winget install ffmpeg" }, manual: "winget install Gyan.FFmpeg" };
+    if (which("choco")) return { auto: { cmd: "choco", args: ["install", "-y", "ffmpeg-full"], label: "choco install ffmpeg-full" }, manual: "choco install ffmpeg-full" };
+    return { manual: "install ffmpeg from ffmpeg.org and add it to PATH", note: "no winget/choco found" };
+  }
+  if (which("apt-get") || which("apt")) return { manual: "sudo apt install ffmpeg", note: "needs sudo \u2014 run it in your shell" };
+  if (which("dnf")) return { manual: "sudo dnf install ffmpeg", note: "needs sudo \u2014 run it in your shell" };
+  if (which("pacman")) return { manual: "sudo pacman -S ffmpeg", note: "needs sudo \u2014 run it in your shell" };
+  return { manual: "install ffmpeg with your package manager", note: "unknown package manager" };
+}
+function runCommand(cmd, args, cb) {
+  let child;
+  try {
+    child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+  } catch (e) {
+    queueMicrotask(() => cb.onDone(false, `couldn't start ${cmd}`));
+    return () => {
+    };
+  }
+  let tail = "";
+  const feed = (chunk) => {
+    tail += chunk.toString();
+    let nl;
+    while ((nl = tail.indexOf("\n")) >= 0) {
+      const line = tail.slice(0, nl).trim();
+      tail = tail.slice(nl + 1);
+      if (line) cb.onLine(line);
+    }
+  };
+  child.stdout?.on("data", feed);
+  child.stderr?.on("data", feed);
+  child.on("error", (e) => cb.onDone(false, e.code === "ENOENT" ? `${cmd} not found` : e.message));
+  child.on("close", (code) => {
+    if (tail.trim()) cb.onLine(tail.trim());
+    cb.onDone(code === 0, code === 0 ? "installed" : `${cmd} exited ${code}`);
+  });
+  return () => {
+    try {
+      child.kill();
+    } catch {
+    }
+  };
+}
+export {
+  ffmpegInstallPlan,
+  runCommand
+};

package/dist/chunks/{server-ZP2DV4IO.js → server-OQNHWL3Z.js}

@@ -6,7 +6,7 @@ import {
   LIMITS,
   PORT,
   PROTO
-} from "./chunk-SF6NNSYZ.js";
+} from "./chunk-WRSSNAIF.js";
 
 // src/server.ts
 import { WebSocketServer, WebSocket } from "ws";
@@ -109,7 +109,6 @@ function sanitizeText(v, maxCp) {
   return out;
 }
 var RoomCore = class {
-  // userId -> trigger times
   constructor(host) {
     this.host = host;
   }
@@ -135,6 +134,11 @@ var RoomCore = class {
   invokeWindow = /* @__PURE__ */ new Map();
   // projectId -> invocation times
   triggerWindow = /* @__PURE__ */ new Map();
+  // userId -> trigger times
+  // voice channel (realtime, loss-tolerant): sids currently in voice, and a
+  // per-sid rate window (voiceFrame is exempt from the general frame flood cap)
+  voiceSids = /* @__PURE__ */ new Set();
+  voiceWindow = /* @__PURE__ */ new Map();
   // ---------- lifecycle ----------
   async onMessage(conn, raw) {
     let msg;
@@ -145,14 +149,16 @@ var RoomCore = class {
     }
     if (!msg || typeof msg !== "object" || typeof msg.t !== "string") return;
     const now = this.host.now();
-    const win = (this.frameWindow.get(conn) ?? []).filter((t) => now - t < 1e4);
-    if (win.length >= LIMITS.framesPerWindow) {
+    if (msg.t !== "voiceFrame") {
+      const win = (this.frameWindow.get(conn) ?? []).filter((t) => now - t < 1e4);
+      if (win.length >= LIMITS.framesPerWindow) {
+        this.frameWindow.set(conn, win);
+        this.host.close(conn, 1008, "frame flood");
+        return;
+      }
+      win.push(now);
       this.frameWindow.set(conn, win);
-      this.host.close(conn, 1008, "frame flood");
-      return;
     }
-    win.push(now);
-    this.frameWindow.set(conn, win);
     try {
       await this.dispatch(conn, msg);
     } catch (e) {
@@ -322,6 +328,34 @@ var RoomCore = class {
         for (const c of this.roomConns(s.projectId)) this.host.send(c, { t: "cleared" });
         break;
       }
+      case "voiceJoin": {
+        if (!s.projectId || this.voiceSids.has(s.sid)) break;
+        this.voiceSids.add(s.sid);
+        this.broadcastVoice(s.projectId);
+        await this.systemLine(s.projectId, `${s.name} joined voice`);
+        break;
+      }
+      case "voiceLeave": {
+        if (!s.projectId || !this.voiceSids.has(s.sid)) break;
+        this.voiceSids.delete(s.sid);
+        this.voiceWindow.delete(s.sid);
+        this.broadcastVoice(s.projectId);
+        await this.systemLine(s.projectId, `${s.name} left voice`);
+        break;
+      }
+      case "voiceFrame": {
+        if (!s.projectId || !this.voiceSids.has(s.sid)) break;
+        const data = typeof msg.data === "string" ? msg.data : "";
+        if (!data || data.length > LIMITS.voiceFrameMaxB64) break;
+        if (!this.rateOk(this.voiceWindow, s.sid, LIMITS.voiceFramesPerSec, 1e3)) break;
+        for (const c of this.roomConns(s.projectId)) {
+          const peer = this.host.getSession(c);
+          if (peer && peer.sid !== s.sid && this.voiceSids.has(peer.sid)) {
+            this.host.send(c, { t: "voiceFrame", sid: s.sid, data });
+          }
+        }
+        break;
+      }
       case "chatSend": {
         if (!s.projectId) break;
         const cmid = String(msg.cmid || "").slice(0, 40);
@@ -519,12 +553,18 @@ var RoomCore = class {
       if (inv && inv.projectId === pid) void this.finalizeInvocation(inv, "partial");
       this.queues.delete(agentId);
     }
+    const wasInVoice = this.voiceSids.delete(s.sid);
+    this.voiceWindow.delete(s.sid);
     s.projectId = null;
     this.host.setSession(conn, s);
     for (const c of this.roomPeers(pid, conn)) {
       this.host.send(c, { t: "cursorGone", sid: s.sid });
     }
     this.broadcastSessions(pid);
+    if (wasInVoice) {
+      this.broadcastVoice(pid);
+      void this.systemLine(pid, `${s.name} left voice`);
+    }
     if (agentsChanged) {
       const p = this.projectsSync?.get(pid);
       if (p) this.broadcastAgents(pid);
@@ -757,6 +797,11 @@ var RoomCore = class {
     const sessions = this.sessionsFor(projectId);
     for (const c of this.roomConns(projectId)) this.host.send(c, { t: "sessions", sessions });
   }
+  /** who is in voice for this project (join/leave presence, not per-frame). */
+  broadcastVoice(projectId) {
+    const peers = this.roomConns(projectId).map((c) => this.host.getSession(c)).filter((s) => !!s && this.voiceSids.has(s.sid)).map((s) => ({ sid: s.sid, userId: s.userId, name: s.name, color: s.color }));
+    for (const c of this.roomConns(projectId)) this.host.send(c, { t: "voice", peers });
+  }
   onlineIds(projectId) {
     return [...new Set(this.sessionsFor(projectId).map((s) => s.userId))];
   }

package/dist/cli.js

@@ -3,7 +3,7 @@ import {
   DEFAULT_SERVER,
   PORT,
   VERSION
-} from "./chunks/chunk-SF6NNSYZ.js";
+} from "./chunks/chunk-WRSSNAIF.js";
 
 // src/cli.ts
 var HELP = `
@@ -52,7 +52,7 @@ async function main() {
       console.error(`invalid port: ${argVal(args, "--port")}`);
       process.exit(1);
     }
-    const { runServer } = await import("./chunks/server-ZP2DV4IO.js");
+    const { runServer } = await import("./chunks/server-OQNHWL3Z.js");
     runServer(port);
     return;
   }
@@ -76,7 +76,7 @@ async function main() {
   const { cachedUpdate, refreshUpdateCache } = await import("./chunks/update-UEPNGB6Y.js");
   refreshUpdateCache();
   const update = cachedUpdate(VERSION);
-  const { runClient } = await import("./chunks/client-7BVK2DEW.js");
+  const { runClient } = await import("./chunks/client-W4563KDL.js");
   runClient({
     name: argVal(args, "--name"),
     server: argVal(args, "--server"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "accelr8",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "Collaborative ascii canvas in your terminal. Real multiplayer, live cursors, mouse-driven TUI.",
   "type": "module",
   "license": "ISC",
@@ -42,7 +42,7 @@
     "chattest": "tsx src/chattest.ts",
     "inputtest": "tsx src/inputtest.ts",
     "torturetest": "tsx src/torturetest.ts",
-    "test": "for t in core chat input ladder boot orb crypto accounts executor agentcontext map voice glyph materialize update contrast; do tsx src/${t}test.ts || exit 1; done && tsx src/rendertest.ts > /dev/null && echo RENDER OK",
+    "test": "for t in core chat input ladder boot orb crypto accounts executor agentcontext map voice glyph materialize update install contrast; do tsx src/${t}test.ts || exit 1; done && tsx src/rendertest.ts > /dev/null && echo RENDER OK",
     "laddertest": "tsx src/laddertest.ts",
     "boottest": "tsx src/boottest.ts",
     "reconnecttest": "tsx src/reconnecttest.ts",
@@ -53,7 +53,8 @@
     "accountstest": "tsx src/accountstest.ts",
     "executortest": "tsx src/executortest.ts",
     "agentcontexttest": "tsx src/agentcontexttest.ts",
-    "chaintest": "tsx src/chaintest.ts"
+    "chaintest": "tsx src/chaintest.ts",
+    "voicetransporttest": "tsx src/voicetransporttest.ts"
   },
   "dependencies": {
     "terminal-kit": "3.1.2",