samoagent 0.3.0

package/dist/cli.js

@@ -0,0 +1,1580 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/config.ts
+import { homedir } from "os";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var RECALL_BASE = "https://us-east-1.recall.ai/api/v1";
+var AVATAR_URL = "https://nikolays.github.io/samoagent/avatar.html";
+
+class ExitError extends Error {
+  code;
+  constructor(code) {
+    super(`ExitError(${code})`);
+    this.code = code;
+    this.name = "ExitError";
+  }
+}
+function repoRoot() {
+  return dirname(dirname(fileURLToPath(import.meta.url)));
+}
+function stateFile() {
+  return process.env.SAMOAGENT_STATE_FILE ?? join(homedir(), ".samoagent", "state.json");
+}
+function dictDir() {
+  return process.env.SAMOAGENT_DICT_DIR ?? join(repoRoot(), "dictionaries");
+}
+function samoagentDir() {
+  const base = process.env.SAMOAGENT_HOME ?? homedir();
+  return join(base, ".samoagent");
+}
+function defaultTranscriptFile() {
+  return join(samoagentDir(), "transcript.txt");
+}
+function apiKey() {
+  const k = process.env.RECALL_API_KEY ?? "";
+  if (!k) {
+    process.stderr.write(`Error: RECALL_API_KEY not set
+`);
+    throw new ExitError(1);
+  }
+  return k;
+}
+function headers() {
+  return {
+    Authorization: `Token ${apiKey()}`,
+    "Content-Type": "application/json"
+  };
+}
+
+// src/commands/join.ts
+import { writeFileSync as writeFileSync4 } from "fs";
+import { randomUUID } from "crypto";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/transcript.ts
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readSync,
+  closeSync
+} from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { StringDecoder } from "string_decoder";
+
+// src/state.ts
+import { chmodSync, existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname as dirname2 } from "path";
+function loadState() {
+  const f = stateFile();
+  if (existsSync(f)) {
+    return JSON.parse(readFileSync(f, "utf-8"));
+  }
+  return {};
+}
+function saveState(state) {
+  const f = stateFile();
+  const dir = dirname2(f);
+  const dirExisted = existsSync(dir);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  if (!dirExisted || process.env.SAMOAGENT_STATE_FILE === undefined) {
+    chmodSync(dir, 448);
+  }
+  writeFileSync(f, JSON.stringify(state, null, 2), { mode: 384 });
+  chmodSync(f, 384);
+}
+function botIdFromArgsOrState(argBotId) {
+  if (argBotId) {
+    return argBotId;
+  }
+  const state = loadState();
+  const bid = state.bot_id;
+  if (!bid || typeof bid !== "string") {
+    process.stderr.write(`Error: no active bot. Pass BOT_ID or run 'samoagent join' first.
+`);
+    throw new ExitError(1);
+  }
+  return bid;
+}
+
+// src/transcript.ts
+var SENTINEL_RE = /^\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\] SAMOAGENT_CALL_ENDED$/;
+function expanduser(p) {
+  if (p === "~")
+    return homedir2();
+  if (p.startsWith("~/"))
+    return join2(homedir2(), p.slice(2));
+  return p;
+}
+function resolveTranscriptFile(transcriptDir) {
+  let d;
+  if (transcriptDir) {
+    d = expanduser(transcriptDir);
+  } else {
+    d = samoagentDir();
+  }
+  mkdirSync2(d, { recursive: true });
+  return join2(d, "transcript.txt");
+}
+function sanitizeTranscriptField(value) {
+  return value.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function formatTranscriptLine(payload) {
+  const p = payload ?? {};
+  if (p.event !== "transcript.data") {
+    return null;
+  }
+  const inner = p.data?.data ?? {};
+  const words = inner.words ?? [];
+  if (!words.length) {
+    return null;
+  }
+  const text = sanitizeTranscriptField(words.map((w) => w.text ?? "").join(" "));
+  const speaker = sanitizeTranscriptField(inner.participant?.name ?? "") || "?";
+  const absolute = words[0]?.start_timestamp?.absolute ?? "";
+  const ts = absolute.slice(0, 19).replace("T", " ");
+  return `[${ts}] ${speaker}: ${text}`;
+}
+function transcriptPathFromState() {
+  const state = loadState();
+  const tf = state.transcript_file;
+  if (typeof tf === "string" && tf) {
+    return tf;
+  }
+  return defaultTranscriptFile();
+}
+function printLocalTranscript() {
+  const tf = transcriptPathFromState();
+  if (existsSync2(tf)) {
+    const lines = readFileSync2(tf, "utf-8").split(/\r?\n/).filter((l) => l.trim() && !SENTINEL_RE.test(l));
+    if (lines.length) {
+      const tail = lines.slice(-20);
+      const base = tf.split("/").pop() ?? tf;
+      process.stdout.write(`
+--- last ${Math.min(20, lines.length)} lines from ${base} ---
+`);
+      for (const line of tail) {
+        process.stdout.write(line + `
+`);
+      }
+    } else {
+      process.stdout.write(`${tf} is empty -- call may not have started yet.
+`);
+    }
+  } else {
+    process.stdout.write(`Transcript not found at ${tf}
+`);
+  }
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function watch(opts = {}) {
+  const pollMs = opts.pollMs ?? 100;
+  const stateGoneCheckEvery = opts.stateGoneCheckEvery ?? 20;
+  const appearWaitMs = opts.appearWaitMs ?? 30000;
+  const tf = transcriptPathFromState();
+  let waited = 0;
+  while (!existsSync2(tf)) {
+    mkdirSync2(join2(tf, ".."), { recursive: true });
+    await sleep(500);
+    waited += 500;
+    if (waited >= appearWaitMs) {
+      writeFileSync2(tf, "");
+      break;
+    }
+  }
+  if (!existsSync2(stateFile())) {
+    process.stderr.write(`No active session. Run 'samoagent join' first.
+`);
+    return;
+  }
+  for (const existing of readFileSync2(tf, "utf-8").split(/\r?\n/)) {
+    if (SENTINEL_RE.test(existing.replace(/\n$/, ""))) {
+      return;
+    }
+  }
+  const fd = openSync(tf, "r");
+  try {
+    let pos = Bun.file(tf).size;
+    let pollCounter = 0;
+    let buffer = "";
+    const chunk = Buffer.alloc(64 * 1024);
+    let decoder = new StringDecoder("utf-8");
+    while (true) {
+      const size = Bun.file(tf).size;
+      if (size < pos) {
+        pos = 0;
+        buffer = "";
+        decoder = new StringDecoder("utf-8");
+      }
+      if (size > pos) {
+        const toRead = size - pos;
+        let remaining = toRead;
+        let offset = pos;
+        let data = "";
+        while (remaining > 0) {
+          const n = readSync(fd, chunk, 0, Math.min(chunk.length, remaining), offset);
+          if (n <= 0)
+            break;
+          data += decoder.write(chunk.subarray(0, n));
+          offset += n;
+          remaining -= n;
+        }
+        pos = offset;
+        buffer += data;
+        let idx;
+        while ((idx = buffer.indexOf(`
+`)) !== -1) {
+          const line = buffer.slice(0, idx);
+          buffer = buffer.slice(idx + 1);
+          if (SENTINEL_RE.test(line.replace(/\r$/, ""))) {
+            return;
+          }
+          process.stdout.write(line + `
+`);
+        }
+      } else {
+        pollCounter += 1;
+        await sleep(pollMs);
+        if (pollCounter % stateGoneCheckEvery === 0 && !existsSync2(stateFile())) {
+          return;
+        }
+      }
+    }
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// src/frameStore.ts
+import {
+  chmodSync as chmodSync2,
+  copyFileSync,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { dirname as dirname3, extname, join as join3, resolve } from "path";
+import { homedir as homedir3 } from "os";
+import { Buffer as Buffer2 } from "buffer";
+function expandUser(path) {
+  if (path === "~")
+    return homedir3();
+  if (path.startsWith("~/"))
+    return join3(homedir3(), path.slice(2));
+  return path;
+}
+function resolveVideoFrameDir(frameDir, create = true) {
+  const dir = frameDir ? expandUser(frameDir) : join3(samoagentDir(), "frames");
+  if (create) {
+    const dirExisted = existsSync3(dir);
+    mkdirSync3(dir, { recursive: true, mode: 448 });
+    if (!dirExisted || !frameDir) {
+      chmodSync2(dir, 448);
+    }
+  }
+  return dir;
+}
+function resolveVideoFrameFile(frameDir, create = true) {
+  return join3(resolveVideoFrameDir(frameDir, create), "latest.png");
+}
+function resolveFrameOutput(out, state) {
+  if (out)
+    return expandUser(out);
+  const stateFile2 = state.video_frame_file;
+  if (typeof stateFile2 === "string" && stateFile2)
+    return expandUser(stateFile2);
+  return resolveVideoFrameFile();
+}
+function safeFilenamePart(value, fallback = "unknown") {
+  const raw = String(value || fallback);
+  const safe = raw.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[-._]+|[-._]+$/g, "");
+  return safe || fallback;
+}
+function frameMetadataPath(framePath) {
+  const ext = extname(framePath);
+  return ext ? framePath.slice(0, -ext.length) + ".json" : framePath + ".json";
+}
+function frameTimestampForFilename(timestamp) {
+  const absolute = timestamp?.absolute;
+  const dt = absolute ? new Date(absolute) : new Date;
+  const valid = Number.isNaN(dt.getTime()) ? new Date : dt;
+  return valid.toISOString().replace(/[-:]/g, "").replace(/\.(\d{3})Z$/, ".$1000Z");
+}
+function archivedFramePath(frameDir, metadata) {
+  const participant = metadata.participant ?? {};
+  const callPart = safeFilenamePart(metadata.call_id, "no-call");
+  const timestampPart = frameTimestampForFilename(metadata.timestamp);
+  const sourceType = safeFilenamePart(metadata.type, "frame");
+  const participantId = safeFilenamePart(participant.id, "unknown");
+  return join3(frameDir, `${callPart}_${timestampPart}_${sourceType}_${participantId}.png`);
+}
+function writeFrameFiles(out, raw, metadata) {
+  const dir = dirname3(out);
+  const dirExisted = existsSync3(dir);
+  mkdirSync3(dir, { recursive: true, mode: 448 });
+  if (!dirExisted) {
+    chmodSync2(dir, 448);
+  }
+  writeFileSync3(out, raw, { mode: 384 });
+  chmodSync2(out, 384);
+  if (metadata !== undefined) {
+    const metadataFile = frameMetadataPath(out);
+    writeFileSync3(metadataFile, JSON.stringify(metadata, null, 2), { mode: 384 });
+    chmodSync2(metadataFile, 384);
+  }
+}
+function archiveFrameBytes(frameDir, raw, metadata) {
+  const archiveFile = archivedFramePath(frameDir, metadata);
+  const archived = {
+    ...metadata,
+    archive_file: archiveFile,
+    archived_at: new Date().toISOString()
+  };
+  writeFrameFiles(archiveFile, raw, archived);
+  return archiveFile;
+}
+function archiveExistingFrame(latestFile) {
+  const metadataFile = frameMetadataPath(latestFile);
+  const metadata = existsSync3(metadataFile) ? JSON.parse(readFileSync3(metadataFile, "utf-8")) : {};
+  const archiveFile = archivedFramePath(dirname3(latestFile), metadata);
+  const archiveDir = dirname3(archiveFile);
+  const dirExisted = existsSync3(archiveDir);
+  mkdirSync3(archiveDir, { recursive: true, mode: 448 });
+  if (!dirExisted) {
+    chmodSync2(archiveDir, 448);
+  }
+  copyFileSync(latestFile, archiveFile);
+  chmodSync2(archiveFile, 384);
+  writeFileSync3(frameMetadataPath(archiveFile), JSON.stringify({
+    ...metadata,
+    archive_file: archiveFile,
+    archived_at: new Date().toISOString()
+  }, null, 2), { mode: 384 });
+  chmodSync2(frameMetadataPath(archiveFile), 384);
+  return archiveFile;
+}
+function decodeVideoSeparatePng(payload, callId) {
+  const p = payload ?? {};
+  if (p.event !== "video_separate_png.data")
+    return null;
+  const inner = p.data?.data ?? {};
+  if (!inner.buffer)
+    return null;
+  const raw = new Uint8Array(Buffer2.from(inner.buffer, "base64"));
+  const participant = inner.participant ?? {};
+  return {
+    raw,
+    metadata: {
+      event: p.event,
+      call_id: callId ?? null,
+      type: inner.type ?? null,
+      participant: {
+        id: participant.id ?? null,
+        name: participant.name ?? null,
+        is_host: participant.is_host ?? null
+      },
+      timestamp: inner.timestamp ?? null,
+      updated_at: new Date().toISOString()
+    }
+  };
+}
+
+// src/dict.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
+function loadDict(name) {
+  if (!name || name.toLowerCase() === "none") {
+    return [];
+  }
+  const path = join4(dictDir(), `${name}.txt`);
+  if (!existsSync4(path)) {
+    process.stdout.write(`Warning: dictionary '${name}' not found at ${path}, continuing without it.
+`);
+    return [];
+  }
+  const terms = readFileSync4(path, "utf-8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
+  return terms.slice(0, 100);
+}
+
+// src/botName.ts
+function botName(agentName) {
+  let base;
+  if (agentName) {
+    base = `${agentName} \uD83D\uDD34 (samoagent)`;
+  } else {
+    base = "samoagent \uD83D\uDD34";
+  }
+  return [...base].slice(0, 100).join("");
+}
+
+// src/recall.ts
+function makeRecallClient(fetchFn = fetch) {
+  return {
+    async leaveCall(botId) {
+      return fetchFn(`${RECALL_BASE}/bot/${botId}/leave_call/`, {
+        method: "POST",
+        headers: headers(),
+        signal: AbortSignal.timeout(1e4)
+      });
+    },
+    async getBot(botId) {
+      const r = await fetchFn(`${RECALL_BASE}/bot/${botId}/`, {
+        method: "GET",
+        headers: headers(),
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!r.ok) {
+        const body = await r.text().catch(() => "");
+        throw new Error(`get bot failed: ${r.status} ${body}`);
+      }
+      try {
+        return await r.json();
+      } catch {
+        throw new Error("get bot failed: invalid JSON response");
+      }
+    },
+    async sendChat(botId, message) {
+      return fetchFn(`${RECALL_BASE}/bot/${botId}/send_chat_message/`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify({ message }),
+        signal: AbortSignal.timeout(1e4)
+      });
+    },
+    async screenshot(botId) {
+      return fetchFn(`${RECALL_BASE}/bot/${botId}/screenshot/`, {
+        method: "GET",
+        headers: headers(),
+        signal: AbortSignal.timeout(15000),
+        redirect: "follow"
+      });
+    },
+    async createBot(payload) {
+      const r = await fetchFn(`${RECALL_BASE}/bot/`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(30000)
+      });
+      if (!r.ok) {
+        const body = await r.text().catch(() => "");
+        throw new Error(`recall.ai bot creation failed: ${r.status} ${body}`);
+      }
+      return r.json();
+    }
+  };
+}
+
+// src/rtmp.ts
+import {
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync4,
+  copyFileSync as copyFileSync2,
+  chmodSync as chmodSync3
+} from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+function rtmpStreamPath(rtmpUrl) {
+  const parsed = new URL(rtmpUrl);
+  return parsed.pathname.replace(/^\/+/, "");
+}
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function ngrokApiPort(fetchFn = fetch) {
+  for (const p of [4040, 4041, 4042, 4043]) {
+    try {
+      const ctrl = AbortSignal.timeout(1000);
+      const r = await fetchFn(`http://localhost:${p}/api/tunnels`, {
+        signal: ctrl
+      });
+      await r.text().catch(() => {
+        return;
+      });
+      return p;
+    } catch {}
+  }
+  return 4040;
+}
+async function waitForNgrok(port, timeout = 15, fetchFn = fetch) {
+  const deadline = Date.now() + timeout * 1000;
+  while (Date.now() < deadline) {
+    try {
+      const apiPort = await ngrokApiPort(fetchFn);
+      const r = await fetchFn(`http://localhost:${apiPort}/api/tunnels`, {
+        signal: AbortSignal.timeout(2000)
+      });
+      const data = await r.json();
+      const tunnels = data.tunnels ?? [];
+      for (const t of tunnels) {
+        if ((t.config?.addr ?? "").includes(String(port))) {
+          return t.public_url;
+        }
+      }
+      if (tunnels.length) {
+        return tunnels[0].public_url;
+      }
+    } catch {}
+    await sleep2(1000);
+  }
+  return null;
+}
+async function startNgrokTcpTunnel(localPort, fetchFn = fetch) {
+  const apiPort = await ngrokApiPort(fetchFn);
+  const payload = JSON.stringify({
+    addr: String(localPort),
+    proto: "tcp",
+    name: "rtmp"
+  });
+  try {
+    const r = await fetchFn(`http://localhost:${apiPort}/api/tunnels`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: payload,
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!r.ok) {
+      const body = await r.text().catch(() => "");
+      if (body.includes("ERR_NGROK_8013") || body.includes("credit or debit card")) {
+        process.stderr.write("Error: ngrok TCP tunnels require a credit/debit card on file " + `(free plan \u2014 your card will NOT be charged).
+` + `Add a card at: https://dashboard.ngrok.com/settings#id-verification
+` + `Then retry with --rtmp.
+`);
+      } else {
+        process.stderr.write(`Error starting ngrok TCP tunnel: ${body.slice(0, 500)}
+`);
+      }
+      return null;
+    }
+    const data = await r.json();
+    return data.public_url ?? null;
+  } catch (e) {
+    process.stderr.write(`Error starting ngrok TCP tunnel: ${e}
+`);
+    return null;
+  }
+}
+async function ensureMediamtx() {
+  const inPath = Bun.which("mediamtx");
+  if (inPath) {
+    return inPath;
+  }
+  const localBin = join5(homedir4(), ".samoagent", "bin", "mediamtx");
+  if (existsSync5(localBin)) {
+    return localBin;
+  }
+  const machine = process.arch;
+  const realArch = machine === "arm64" || machine === "aarch64" ? "arm64" : "amd64";
+  const plat = process.platform;
+  if (plat !== "darwin" && plat !== "linux") {
+    throw new Error(`Unsupported platform for mediamtx auto-download: ${plat}`);
+  }
+  const version = "v1.9.1";
+  const filename = `mediamtx_${version}_${plat}_${realArch}.tar.gz`;
+  const url = `https://github.com/bluenviron/mediamtx/releases/download/${version}/${filename}`;
+  process.stdout.write(`Downloading mediamtx ${version}...
+`);
+  const tmpdir = join5(homedir4(), ".samoagent", "tmp-mediamtx");
+  mkdirSync4(tmpdir, { recursive: true });
+  const archivePath = join5(tmpdir, filename);
+  const resp = await fetch(url);
+  if (!resp.ok) {
+    throw new Error(`Failed to download mediamtx: ${resp.status}`);
+  }
+  await Bun.write(archivePath, resp);
+  await Bun.$`tar -xzf ${archivePath} -C ${tmpdir} mediamtx`.quiet();
+  const extracted = join5(tmpdir, "mediamtx");
+  if (!existsSync5(extracted)) {
+    throw new Error("mediamtx binary not found in downloaded archive");
+  }
+  mkdirSync4(join5(localBin, ".."), { recursive: true });
+  copyFileSync2(extracted, localBin);
+  chmodSync3(localBin, 493);
+  return localBin;
+}
+async function startMediamtx() {
+  const mediamtxBin = await ensureMediamtx();
+  const proc = Bun.spawn([mediamtxBin], {
+    stdout: "ignore",
+    stderr: "ignore"
+  });
+  await sleep2(1500);
+  if (proc.exitCode !== null) {
+    return null;
+  }
+  return proc;
+}
+
+// src/commands/join.ts
+function defaultKill(pid, signal) {
+  try {
+    process.kill(pid, signal);
+  } catch {}
+}
+function defaultSpawn(cmd) {
+  const proc = Bun.spawn(cmd, { stdout: "ignore", stderr: "ignore" });
+  return {
+    get pid() {
+      return proc.pid;
+    },
+    kill() {
+      proc.kill();
+    }
+  };
+}
+async function cmdJoin(args, deps = {}) {
+  const recall = deps.recall ?? makeRecallClient();
+  const kill = deps.kill ?? defaultKill;
+  const spawn = deps.spawn ?? defaultSpawn;
+  const waitForNgrokFn = deps.waitForNgrok ?? waitForNgrok;
+  const startMediamtxFn = deps.startMediamtx ?? startMediamtx;
+  const startNgrokTcpTunnelFn = deps.startNgrokTcpTunnel ?? startNgrokTcpTunnel;
+  const transcriptFile = resolveTranscriptFile(args.transcript_dir);
+  writeFileSync4(transcriptFile, "");
+  const webhookToken = randomUUID();
+  const frameToken = randomUUID();
+  const keyterms = loadDict(args.dict);
+  const name = botName(args.name);
+  const port = args.port || 8080;
+  let rtmpUrl = args.rtmp_url ?? null;
+  const useRtmpAuto = args.rtmp ?? false;
+  const useWsVideo = args.ws_video ?? false;
+  const videoFrameDir = resolveVideoFrameDir(args.frame_dir, false);
+  const videoFrameFile = resolveVideoFrameFile(args.frame_dir, false);
+  const oldState = loadState();
+  for (const pidKey of ["server_pid", "ngrok_pid", "mediamtx_pid"]) {
+    const pid = oldState[pidKey];
+    if (typeof pid === "number" && pid) {
+      kill(pid, "SIGTERM");
+    }
+  }
+  const selfPath = fileURLToPath2(import.meta.url);
+  const cliPath = selfPath.replace(/commands\/join\.ts$/, "cli.ts");
+  const server = spawn([
+    process.execPath,
+    cliPath,
+    "_serve",
+    "--port",
+    String(port),
+    "--transcript-file",
+    transcriptFile,
+    "--webhook-token",
+    webhookToken,
+    "--call-id-file",
+    stateFile(),
+    "--frame-token",
+    frameToken
+  ]);
+  const started = new Set([server]);
+  let stateSaved = false;
+  const cleanupUnsaved = () => {
+    if (stateSaved)
+      return;
+    for (const proc of started) {
+      proc.kill();
+    }
+    started.clear();
+  };
+  const ngrok = spawn(["ngrok", "http", String(port), "--log=stdout"]);
+  started.add(ngrok);
+  try {
+    process.stdout.write(`Starting ngrok tunnel on port ${port}...
+`);
+    let webhookUrl = await waitForNgrokFn(port);
+    if (!webhookUrl) {
+      process.stderr.write(`Error: could not get ngrok URL. Is ngrok installed and authenticated?
+`);
+      cleanupUnsaved();
+      throw new ExitError(1);
+    }
+    webhookUrl = webhookUrl.replace(/\/+$/, "") + `/webhook?token=${encodeURIComponent(webhookToken)}`;
+    process.stdout.write(`Webhook: ${webhookUrl}
+`);
+    let mediamtxAuto = null;
+    let rtmpViaNgrok = false;
+    if (useRtmpAuto && !rtmpUrl) {
+      process.stdout.write(`Starting mediamtx RTMP server for --rtmp...
+`);
+      const mediamtxEarly = await startMediamtxFn();
+      if (!mediamtxEarly) {
+        process.stderr.write(`Warning: mediamtx failed to start \u2014 RTMP frame capture disabled.
+`);
+      } else {
+        process.stdout.write(`Opening ngrok TCP tunnel to port 1935...
+`);
+        started.add(mediamtxEarly);
+        const tcpPublic = await startNgrokTcpTunnelFn(1935);
+        if (tcpPublic === null) {
+          process.stderr.write(`Warning: ngrok TCP tunnel failed \u2014 RTMP frame capture disabled.
+`);
+          mediamtxEarly.kill();
+          started.delete(mediamtxEarly);
+        } else {
+          rtmpUrl = tcpPublic.replace("tcp://", "rtmp://") + "/live/call";
+          process.stdout.write(`ngrok TCP tunnel: ${tcpPublic}
+`);
+          process.stdout.write(`RTMP URL for recall.ai: ${rtmpUrl}
+`);
+          mediamtxAuto = mediamtxEarly;
+          rtmpViaNgrok = true;
+        }
+      }
+    }
+    process.stdout.write(`Joining: ${args.url}
+`);
+    const deepgramConfig = {
+      model: "nova-3",
+      language: "multi",
+      mip_opt_out: true
+    };
+    if (keyterms.length) {
+      deepgramConfig.keyterms = keyterms;
+    }
+    const realtimeEndpoints = [
+      {
+        type: "webhook",
+        url: webhookUrl,
+        events: ["transcript.data"]
+      }
+    ];
+    let mediamtxProc = null;
+    let rtmpLocalUrl = null;
+    let wsVideoUrl = null;
+    if (useWsVideo) {
+      wsVideoUrl = webhookUrl.replace(/\/webhook(?:\?.*)?$/, "/video-ws").replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
+      wsVideoUrl += `?token=${encodeURIComponent(frameToken)}`;
+      realtimeEndpoints.push({
+        type: "websocket",
+        url: wsVideoUrl,
+        events: ["video_separate_png.data"]
+      });
+      process.stdout.write(`WebSocket video: recall.ai \u2192 token-protected /video-ws \u2192 in-memory latest frame
+`);
+    }
+    if (rtmpUrl) {
+      const rtmpHost = new URL(rtmpUrl).hostname || "";
+      const rtmpIsLocal = rtmpHost === "localhost" || rtmpHost === "127.0.0.1";
+      if (rtmpIsLocal) {
+        process.stdout.write(`Starting mediamtx RTMP server...
+`);
+        mediamtxProc = await startMediamtxFn();
+        if (!mediamtxProc) {
+          process.stderr.write(`Warning: mediamtx failed to start \u2014 RTMP frame capture disabled.
+`);
+          rtmpUrl = null;
+        } else {
+          started.add(mediamtxProc);
+          const streamPath = rtmpStreamPath(rtmpUrl);
+          rtmpLocalUrl = `rtmp://localhost:1935/${streamPath}`;
+          realtimeEndpoints.push({
+            type: "rtmp",
+            url: rtmpUrl,
+            events: ["video_mixed_flv.data"]
+          });
+          process.stdout.write(`RTMP: recall.ai \u2192 ${rtmpUrl} \u2192 mediamtx (local) \u2192 ${rtmpLocalUrl}
+`);
+        }
+      } else if (useRtmpAuto && rtmpViaNgrok) {
+        mediamtxProc = mediamtxAuto;
+        const streamPath = rtmpStreamPath(rtmpUrl);
+        rtmpLocalUrl = `rtmp://localhost:1935/${streamPath}`;
+        realtimeEndpoints.push({
+          type: "rtmp",
+          url: rtmpUrl,
+          events: ["video_mixed_flv.data"]
+        });
+        process.stdout.write(`RTMP: recall.ai \u2192 ${rtmpUrl} (ngrok TCP) \u2192 mediamtx (local) \u2192 ${rtmpLocalUrl}
+`);
+      } else {
+        rtmpLocalUrl = rtmpUrl;
+        realtimeEndpoints.push({
+          type: "rtmp",
+          url: rtmpUrl,
+          events: ["video_mixed_flv.data"]
+        });
+        process.stdout.write(`RTMP: recall.ai \u2192 ${rtmpUrl} (remote mediamtx; ffmpeg reads directly)
+`);
+      }
+    }
+    const recordingConfig = {
+      transcript: {
+        provider: { deepgram_streaming: deepgramConfig },
+        diarization: { use_separate_streams_when_available: true }
+      },
+      screenshot: {},
+      realtime_endpoints: realtimeEndpoints
+    };
+    if (rtmpUrl) {
+      recordingConfig.video_mixed_flv = {};
+    }
+    if (useWsVideo) {
+      recordingConfig.video_separate_png = {};
+    }
+    const payload = {
+      meeting_url: args.url,
+      bot_name: name,
+      output_media: {
+        camera: {
+          kind: "webpage",
+          config: { url: AVATAR_URL }
+        }
+      },
+      recording_config: recordingConfig
+    };
+    const bot = await recall.createBot(payload);
+    const bid = bot.id;
+    const newState = {
+      bot_id: bid,
+      agent_name: args.name || "samoagent",
+      bot_name: name,
+      webhook_url: webhookUrl,
+      server_pid: server.pid,
+      ngrok_pid: ngrok.pid,
+      started_at: new Date().toISOString(),
+      dict: args.dict ?? null,
+      meeting_url: args.url,
+      transcript_file: transcriptFile
+    };
+    if (mediamtxProc) {
+      newState.mediamtx_pid = mediamtxProc.pid;
+    }
+    if (rtmpLocalUrl) {
+      newState.rtmp_local_url = rtmpLocalUrl;
+    }
+    if (useWsVideo) {
+      newState.local_frame_url = `http://127.0.0.1:${port}/frame`;
+      newState.local_frame_metadata_url = `http://127.0.0.1:${port}/frame.json`;
+      newState.frame_token = frameToken;
+      newState.video_frame_dir = videoFrameDir;
+      newState.video_frame_file = videoFrameFile;
+    }
+    saveState(newState);
+    stateSaved = true;
+    process.stdout.write(`Bot ID:   ${bid}
+`);
+    process.stdout.write(`Bot name: ${name}
+`);
+    process.stdout.write(`Dict:     ${args.dict || "none"} (${keyterms.length} terms)
+`);
+    process.stdout.write(`Transcript -> ${transcriptFile}
+`);
+    process.stdout.write(`
+The agent will appear in the call within ~15 seconds.
+`);
+    process.stdout.write(`
+--- AGENT INSTRUCTIONS ---
+`);
+    process.stdout.write(`IMPORTANT: You must now monitor the live transcript for the duration of the call.
+`);
+    process.stdout.write(`Run this command with your Monitor tool (persistent=true):
+`);
+    process.stdout.write(`  samoagent watch
+`);
+    process.stdout.write(`Each line you receive is a new utterance: [timestamp] Speaker: text
+`);
+    process.stdout.write(`React to what is said. If someone addresses you or asks a question, respond in chat.
+`);
+    process.stdout.write(`To send a message in the meeting chat: samoagent chat 'your message'
+`);
+    if (rtmpLocalUrl) {
+      process.stdout.write(`To capture call frame:        samoagent frame  (ffmpeg from RTMP stream)
+`);
+    } else if (useWsVideo) {
+      process.stdout.write(`To capture call frame:        samoagent frame  (latest WebSocket PNG, written on demand)
+`);
+    } else {
+      process.stdout.write(`To capture what's on screen:  samoagent screenshot  (then Read screenshot.png)
+`);
+    }
+    process.stdout.write(`To stop:                      samoagent leave
+`);
+    process.stdout.write(`--------------------------
+`);
+  } catch (err) {
+    cleanupUnsaved();
+    throw err;
+  }
+}
+
+// src/commands/leave.ts
+import { existsSync as existsSync6, unlinkSync, appendFileSync } from "fs";
+function defaultKill2(pid, signal) {
+  process.kill(pid, signal);
+}
+function fmtSentinelTs(d) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+async function cmdLeave(args, deps = {}) {
+  const recall = deps.recall ?? makeRecallClient();
+  const kill = deps.kill ?? defaultKill2;
+  const now = deps.now ?? (() => new Date);
+  const bid = botIdFromArgsOrState(args.bot_id);
+  try {
+    await recall.leaveCall(bid);
+    process.stdout.write(`Bot ${bid} left the call.
+`);
+  } catch (e) {
+    process.stdout.write(`Warning: ${e}
+`);
+  }
+  const state = loadState();
+  const transcriptFile = state.transcript_file;
+  if (typeof transcriptFile === "string" && transcriptFile) {
+    if (existsSync6(transcriptFile)) {
+      const ts = fmtSentinelTs(now());
+      try {
+        appendFileSync(transcriptFile, `[${ts}] SAMOAGENT_CALL_ENDED
+`);
+      } catch {}
+    }
+  }
+  for (const pidKey of ["server_pid", "ngrok_pid", "mediamtx_pid"]) {
+    const pid = state[pidKey];
+    if (typeof pid === "number" && pid) {
+      try {
+        kill(pid, "SIGTERM");
+        process.stdout.write(`Stopped ${pidKey.replace("_pid", "")} (pid ${pid})
+`);
+      } catch (e) {
+        if (e.code !== "ESRCH") {}
+      }
+    }
+  }
+  if (existsSync6(stateFile())) {
+    unlinkSync(stateFile());
+  }
+  process.stdout.write(`Done.
+`);
+}
+
+// src/commands/status.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+async function cmdStatus(args, deps = {}) {
+  const recall = deps.recall ?? makeRecallClient();
+  const bid = botIdFromArgsOrState(args.bot_id);
+  const bot = await recall.getBot(bid);
+  const changes = bot.status_changes ?? [];
+  const status = changes.length ? changes[changes.length - 1].code ?? "unknown" : "joining";
+  const name = bot.bot_name ?? "?";
+  process.stdout.write(`Bot:    ${bid}
+`);
+  process.stdout.write(`Name:   ${name}
+`);
+  process.stdout.write(`Status: ${status}
+`);
+  const state = loadState();
+  const tf = typeof state.transcript_file === "string" ? state.transcript_file : defaultTranscriptFile();
+  if (existsSync7(tf)) {
+    const lines = readFileSync5(tf, "utf-8").split(/\r?\n/).filter((l) => l.trim() && !SENTINEL_RE.test(l));
+    process.stdout.write(`Transcript lines so far: ${lines.length}
+`);
+    process.stdout.write(`Transcript file: ${tf}
+`);
+  }
+}
+
+// src/commands/screenshot.ts
+import { resolve as resolve2 } from "path";
+var sleep3 = (ms) => new Promise((r) => setTimeout(r, ms));
+function defaultRun(cmd) {
+  const proc = Bun.spawnSync(cmd);
+  return { exitCode: proc.exitCode };
+}
+function defaultFocus(meetingUrl) {
+  const domain = meetingUrl.includes("meet.google.com") ? "meet.google.com" : "zoom.us";
+  const script = `
+tell application "Google Chrome"
+    set found to false
+    repeat with w in windows
+        set tabIdx to 0
+        repeat with t in tabs of w
+            set tabIdx to tabIdx + 1
+            if URL of t contains "${domain}" then
+                set active tab index of w to tabIdx
+                set index of w to 1
+                set found to true
+                exit repeat
+            end if
+        end repeat
+        if found then exit repeat
+    end repeat
+end tell
+tell application "Google Chrome" to activate
+`;
+  try {
+    Bun.spawnSync(["osascript", "-e", script], {
+      timeout: 5000,
+      stdout: "ignore",
+      stderr: "ignore"
+    });
+  } catch {}
+}
+async function cmdScreenshot(args, deps = {}) {
+  const run = deps.run ?? defaultRun;
+  const focus = deps.focus ?? defaultFocus;
+  const out = args.out || "screenshot.png";
+  const state = loadState();
+  const meetingUrl = state.meeting_url ?? "";
+  if (meetingUrl.includes("meet.google.com") || meetingUrl.includes("zoom.us")) {
+    focus(meetingUrl);
+    await sleep3(1000);
+  }
+  const result = run(["screencapture", "-x", out]);
+  if (result.exitCode !== 0) {
+    throw new Error(`screencapture failed with code ${result.exitCode}`);
+  }
+  process.stdout.write(resolve2(out) + `
+`);
+}
+
+// src/commands/transcript.ts
+async function cmdTranscript(args, deps = {}) {
+  const recall = deps.recall ?? makeRecallClient();
+  const fetchFn = deps.fetchFn ?? fetch;
+  const bid = botIdFromArgsOrState(args.bot_id);
+  const bot = await recall.getBot(bid);
+  const recordings = bot.recordings ?? [];
+  if (!recordings.length) {
+    process.stdout.write(`No recordings yet.
+`);
+    printLocalTranscript();
+    return;
+  }
+  const media = recordings[0].media_shortcuts?.transcript ?? {};
+  const statusCode = media.status?.code ?? "?";
+  const downloadUrl = media.data?.download_url;
+  if (downloadUrl) {
+    const r = await fetchFn(downloadUrl, { signal: AbortSignal.timeout(30000) });
+    const data = await r.json();
+    for (const entry of data) {
+      const words = (entry.words ?? []).map((w) => w.text ?? "").join(" ");
+      const speaker = entry.speaker ?? "?";
+      const start = entry.words?.[0]?.start_time ?? 0;
+      process.stdout.write(`[${start.toFixed(1)}s] ${speaker}: ${words}
+`);
+    }
+  } else {
+    process.stdout.write(`Transcript status: ${statusCode}
+`);
+    printLocalTranscript();
+  }
+}
+
+// src/commands/chat.ts
+async function cmdChat(args, deps = {}) {
+  const recall = deps.recall ?? makeRecallClient();
+  const bid = botIdFromArgsOrState(args.bot_id);
+  const resp = await recall.sendChat(bid, args.message ?? "");
+  if (!resp.ok) {
+    const body = await resp.text().catch(() => "");
+    throw new Error(`send_chat_message failed: ${resp.status} ${body}`);
+  }
+  process.stdout.write(`Sent: ${args.message}
+`);
+}
+
+// src/commands/frame.ts
+import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname4, resolve as resolve3 } from "path";
+function defaultRun2(cmd) {
+  const proc = Bun.spawnSync(cmd, { timeout: 15000 });
+  return { returncode: proc.exitCode, stderr: proc.stderr };
+}
+async function cmdFrame(args, deps = {}) {
+  const recall = deps.recall ?? makeRecallClient();
+  const fetchFn = deps.fetchFn ?? fetch;
+  const run = deps.run ?? defaultRun2;
+  const state = loadState();
+  const archive = args.archive ?? false;
+  const out = resolveFrameOutput(args.out, state);
+  const rtmpLocalUrl = state.rtmp_local_url;
+  if (typeof rtmpLocalUrl === "string" && rtmpLocalUrl) {
+    let ffmpeg = "/opt/homebrew/bin/ffmpeg";
+    if (!existsSync8(ffmpeg)) {
+      ffmpeg = "ffmpeg";
+    }
+    const cmd = [
+      ffmpeg,
+      "-y",
+      "-i",
+      rtmpLocalUrl,
+      "-vframes",
+      "1",
+      "-update",
+      "1",
+      "-q:v",
+      "2",
+      out
+    ];
+    const result = run(cmd);
+    if (result.returncode === 0 && existsSync8(out)) {
+      process.stdout.write(resolve3(out) + `
+`);
+      return;
+    }
+    process.stderr.write(`FRAME_ERROR: ffmpeg failed to grab frame from ${rtmpLocalUrl}
+`);
+    const errText = Buffer.from(result.stderr).toString("utf-8");
+    process.stderr.write(errText.slice(-500) + `
+`);
+    throw new ExitError(1);
+  }
+  const localFrameUrl = state.local_frame_url;
+  if (typeof localFrameUrl === "string" && localFrameUrl) {
+    const headers2 = {};
+    if (typeof state.frame_token === "string" && state.frame_token) {
+      headers2["X-Samoagent-Frame-Token"] = state.frame_token;
+    }
+    let resp2;
+    try {
+      resp2 = await fetchFn(localFrameUrl, { headers: headers2 });
+    } catch (e) {
+      process.stderr.write(`FRAME_UNAVAILABLE: local WebSocket frame server is not reachable: ${e instanceof Error ? e.message : String(e)}
+`);
+      throw new ExitError(1);
+    }
+    const contentType2 = resp2.headers.get("content-type") ?? "";
+    if (resp2.status === 200 && contentType2.startsWith("image/")) {
+      let metadata = {};
+      const metadataUrl = state.local_frame_metadata_url;
+      if (typeof metadataUrl === "string" && metadataUrl) {
+        try {
+          const metaResp = await fetchFn(metadataUrl, { headers: headers2 });
+          if (metaResp.status === 200) {
+            metadata = await metaResp.json();
+          }
+        } catch {
+          metadata = {};
+        }
+      }
+      const raw = new Uint8Array(await resp2.arrayBuffer());
+      const output = archive && !args.out ? archiveFrameBytes(String(state.video_frame_dir ?? dirname4(out)), raw, metadata) : out;
+      if (!(archive && !args.out)) {
+        writeFrameFiles(output, raw, metadata);
+      }
+      process.stdout.write(resolve3(output) + `
+`);
+      return;
+    }
+    process.stderr.write(`FRAME_UNAVAILABLE: no WebSocket video frame received yet.
+`);
+    process.stderr.write(`Wait for Recall to deliver video_separate_png.data, then retry.
+`);
+    throw new ExitError(1);
+  }
+  const legacyFrameFile = state.video_frame_file;
+  if (typeof legacyFrameFile === "string" && legacyFrameFile && existsSync8(legacyFrameFile)) {
+    const output = archive && !args.out ? archiveExistingFrame(legacyFrameFile) : out;
+    if (!(archive && !args.out)) {
+      writeFileSync5(output, readFileSync6(legacyFrameFile));
+      const metadataFile = frameMetadataPath(legacyFrameFile);
+      if (existsSync8(metadataFile)) {
+        writeFileSync5(frameMetadataPath(output), readFileSync6(metadataFile));
+      }
+    }
+    process.stdout.write(resolve3(output) + `
+`);
+    return;
+  }
+  const bid = botIdFromArgsOrState(args.bot_id);
+  const resp = await recall.screenshot(bid);
+  const contentType = resp.headers.get("content-type") ?? "";
+  if (resp.status === 200 && contentType.startsWith("image/")) {
+    const buf = new Uint8Array(await resp.arrayBuffer());
+    writeFileSync5(out, buf);
+    process.stdout.write(resolve3(out) + `
+`);
+    return;
+  }
+  const meetingUrl = state.meeting_url ?? "";
+  process.stderr.write(`FRAME_UNAVAILABLE: no RTMP stream configured and recall.ai live frame not available.
+`);
+  process.stderr.write(`Options:
+`);
+  process.stderr.write(`  1. Rejoin with --rtmp to enable RTMP frames via ngrok TCP (no VM needed; requires ngrok card on file)
+`);
+  process.stderr.write(`  2. Rejoin with --rtmp-url rtmp://PUBLIC_IP:1935/live/call to enable RTMP frames via cloud VM
+`);
+  process.stderr.write(`  3. Use browser tools to screenshot: ${meetingUrl}
+`);
+  process.stderr.write(`  4. After call ends: samoagent transcript
+`);
+  throw new ExitError(1);
+}
+
+// src/commands/dicts.ts
+import { existsSync as existsSync9, readdirSync, readFileSync as readFileSync7 } from "fs";
+import { join as join6, basename } from "path";
+async function cmdDicts() {
+  const dir = dictDir();
+  if (!existsSync9(dir)) {
+    process.stdout.write(`No dictionaries directory found.
+`);
+    return;
+  }
+  const files = readdirSync(dir).filter((f) => f.endsWith(".txt")).sort().map((f) => join6(dir, f));
+  if (!files.length) {
+    process.stdout.write(`No dictionaries found.
+`);
+    return;
+  }
+  process.stdout.write(`Available dictionaries:
+`);
+  for (const f of files) {
+    const terms = readFileSync7(f, "utf-8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
+    const stem = basename(f, ".txt");
+    process.stdout.write(`  ${stem} (${terms.length} terms)
+`);
+  }
+}
+
+// src/commands/watch.ts
+async function cmdWatch() {
+  await watch();
+}
+
+// src/server.ts
+import { appendFileSync as appendFileSync2 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
+import { Buffer as Buffer3 } from "buffer";
+var WEBHOOK_MAX_BYTES = 1024 * 1024;
+async function handleWebhook(payload, transcriptPath) {
+  const line = formatTranscriptLine(payload);
+  if (line !== null) {
+    appendFileSync2(transcriptPath, line + `
+`);
+  }
+}
+function callIdFromStateFile(path) {
+  if (!path)
+    return null;
+  try {
+    const state = JSON.parse(readFileSync8(path, "utf-8"));
+    return typeof state.bot_id === "string" ? state.bot_id : null;
+  } catch {
+    return null;
+  }
+}
+function serve(port, transcriptPath, options = {}) {
+  const opts = typeof options === "string" || options === null ? { webhookToken: options } : options;
+  const latestVideoFrame = { raw: null, metadata: null };
+  const frameAuthorized = (req) => Boolean(opts.frameToken) && req.headers.get("X-Samoagent-Frame-Token") === opts.frameToken;
+  return Bun.serve({
+    port,
+    hostname: "0.0.0.0",
+    async fetch(req, server) {
+      const url = new URL(req.url);
+      if (req.method === "POST" && url.pathname === "/webhook") {
+        if (!opts.webhookToken || url.searchParams.get("token") !== opts.webhookToken) {
+          return Response.json({ error: "forbidden" }, { status: 403 });
+        }
+        const contentLength = req.headers.get("content-length");
+        if (contentLength !== null && Number(contentLength) > WEBHOOK_MAX_BYTES) {
+          return Response.json({ error: "payload too large" }, { status: 413 });
+        }
+        let payload = {};
+        try {
+          const body = await req.text();
+          if (body.length > WEBHOOK_MAX_BYTES) {
+            return Response.json({ error: "payload too large" }, { status: 413 });
+          }
+          payload = body ? JSON.parse(body) : {};
+        } catch {
+          payload = {};
+        }
+        await handleWebhook(payload, transcriptPath);
+        return Response.json({ ok: true });
+      }
+      if (req.method === "GET" && url.pathname === "/frame") {
+        if (!frameAuthorized(req)) {
+          return new Response("", { status: 403 });
+        }
+        if (latestVideoFrame.raw === null) {
+          return new Response("", { status: 404 });
+        }
+        return new Response(latestVideoFrame.raw, {
+          headers: { "Content-Type": "image/png" }
+        });
+      }
+      if (req.method === "GET" && url.pathname === "/frame.json") {
+        if (!frameAuthorized(req)) {
+          return Response.json({ error: "forbidden" }, { status: 403 });
+        }
+        if (latestVideoFrame.metadata === null) {
+          return Response.json({ error: "no frame" }, { status: 404 });
+        }
+        return Response.json(latestVideoFrame.metadata);
+      }
+      if (url.pathname === "/video-ws") {
+        if (!opts.frameToken || url.searchParams.get("token") !== opts.frameToken) {
+          return new Response("", { status: 403 });
+        }
+        const upgraded = server.upgrade(req);
+        if (upgraded)
+          return;
+        return new Response("Upgrade Required", { status: 426 });
+      }
+      return new Response("Not Found", { status: 404 });
+    },
+    websocket: {
+      message(_ws, message) {
+        let payload;
+        try {
+          const text = typeof message === "string" ? message : Buffer3.from(message).toString("utf-8");
+          payload = JSON.parse(text);
+        } catch {
+          return;
+        }
+        const decoded = decodeVideoSeparatePng(payload, opts.currentCallId?.() ?? null);
+        if (decoded === null)
+          return;
+        latestVideoFrame.raw = decoded.raw;
+        latestVideoFrame.metadata = decoded.metadata;
+      }
+    }
+  });
+}
+
+// src/commands/serve.ts
+async function cmdServe(args) {
+  const port = args.port || 8080;
+  const transcriptPath = args.transcript_file;
+  serve(port, transcriptPath, {
+    webhookToken: args.webhook_token,
+    frameToken: args.frame_token,
+    currentCallId: () => callIdFromStateFile(args.call_id_file)
+  });
+  await new Promise(() => {});
+}
+
+// src/cli.ts
+var USAGE = `usage: samoagent <command> [options]
+
+AI meeting agent for Zoom & Google Meet
+
+commands:
+  join <url> [--name N] [--dict D] [--port P] [--transcript-dir DIR] [--rtmp-url URL] [--rtmp] [--no-ws-video] [--frame-dir DIR]
+  leave [bot_id]
+  status [bot_id]
+  screenshot [--out FILE] [bot_id]
+  chat <message> [--bot-id ID]
+  transcript [bot_id]
+  dicts
+  watch
+  frame [--out FILE] [--archive] [bot_id]
+`;
+
+class ArgError extends Error {
+}
+function parseArgs(argv) {
+  if (argv.length === 0) {
+    throw new ArgError("the following arguments are required: command");
+  }
+  const command = argv[0];
+  const rest = argv.slice(1);
+  const positionals = [];
+  const opts = {};
+  const valueFlags = {
+    join: new Set(["--name", "--dict", "--port", "--transcript-dir", "--rtmp-url", "--frame-dir"]),
+    leave: new Set,
+    status: new Set,
+    screenshot: new Set(["--out"]),
+    chat: new Set(["--bot-id"]),
+    transcript: new Set,
+    dicts: new Set,
+    watch: new Set,
+    frame: new Set(["--out"]),
+    _serve: new Set(["--port", "--transcript-file", "--webhook-token", "--call-id-file", "--frame-token"])
+  };
+  const boolFlags = {
+    join: new Set(["--rtmp", "--no-ws-video"]),
+    leave: new Set,
+    status: new Set,
+    screenshot: new Set,
+    chat: new Set,
+    transcript: new Set,
+    dicts: new Set,
+    watch: new Set,
+    frame: new Set(["--archive"]),
+    _serve: new Set
+  };
+  const knownCommands = Object.keys(valueFlags);
+  if (!knownCommands.includes(command)) {
+    throw new ArgError(`invalid choice: '${command}'`);
+  }
+  const vFlags = valueFlags[command];
+  const bFlags = boolFlags[command];
+  for (let i = 0;i < rest.length; i++) {
+    const tok = rest[i];
+    if (tok.startsWith("--")) {
+      const eq = tok.indexOf("=");
+      if (eq !== -1) {
+        const flag = tok.slice(0, eq);
+        const val = tok.slice(eq + 1);
+        if (vFlags.has(flag)) {
+          opts[flag] = val;
+        } else {
+          throw new ArgError(`unrecognized arguments: ${tok}`);
+        }
+        continue;
+      }
+      if (bFlags.has(tok)) {
+        opts[tok] = true;
+        continue;
+      }
+      if (vFlags.has(tok)) {
+        const val = rest[i + 1];
+        if (val === undefined) {
+          throw new ArgError(`argument ${tok}: expected one argument`);
+        }
+        opts[tok] = val;
+        i += 1;
+        continue;
+      }
+      throw new ArgError(`unrecognized arguments: ${tok}`);
+    } else {
+      positionals.push(tok);
+    }
+  }
+  const result = { command };
+  switch (command) {
+    case "join": {
+      if (positionals.length < 1) {
+        throw new ArgError("the following arguments are required: url");
+      }
+      result.url = positionals[0];
+      result.name = opts["--name"] ?? null;
+      result.dict = opts["--dict"] ?? null;
+      const rawPort = opts["--port"];
+      if (rawPort !== undefined) {
+        const p = Number(rawPort);
+        if (!Number.isInteger(p) || p < 1 || p > 65535) {
+          throw new ArgError(`argument --port: invalid port number: '${rawPort}'`);
+        }
+        result.port = p;
+      } else {
+        result.port = 8080;
+      }
+      result.transcript_dir = opts["--transcript-dir"] ?? null;
+      result.rtmp_url = opts["--rtmp-url"] ?? null;
+      result.rtmp = opts["--rtmp"] === true;
+      result.ws_video = opts["--no-ws-video"] !== true;
+      result.frame_dir = opts["--frame-dir"] ?? null;
+      break;
+    }
+    case "leave":
+    case "status":
+    case "transcript": {
+      result.bot_id = positionals.length ? positionals[0] : null;
+      break;
+    }
+    case "screenshot": {
+      result.out = opts["--out"] ?? "screenshot.png";
+      result.bot_id = positionals.length ? positionals[0] : null;
+      break;
+    }
+    case "frame": {
+      result.out = opts["--out"] ?? null;
+      result.archive = opts["--archive"] === true;
+      result.bot_id = positionals.length ? positionals[0] : null;
+      break;
+    }
+    case "chat": {
+      if (positionals.length < 1) {
+        throw new ArgError("the following arguments are required: message");
+      }
+      result.message = positionals[0];
+      result.bot_id = opts["--bot-id"] ?? null;
+      break;
+    }
+    case "dicts":
+    case "watch":
+      break;
+    case "_serve": {
+      const rawPort2 = opts["--port"];
+      if (rawPort2 !== undefined) {
+        const p2 = Number(rawPort2);
+        if (!Number.isInteger(p2) || p2 < 1 || p2 > 65535) {
+          throw new ArgError(`argument --port: invalid port number: '${rawPort2}'`);
+        }
+        result.port = p2;
+      } else {
+        result.port = 8080;
+      }
+      if (opts["--transcript-file"] === undefined) {
+        throw new ArgError("the following arguments are required: --transcript-file");
+      }
+      result.transcript_file = opts["--transcript-file"];
+      result.webhook_token = opts["--webhook-token"] ?? "";
+      result.call_id_file = opts["--call-id-file"] ?? "";
+      result.frame_token = opts["--frame-token"] ?? "";
+      break;
+    }
+  }
+  return result;
+}
+async function dispatch(args) {
+  switch (args.command) {
+    case "join":
+      return cmdJoin(args);
+    case "leave":
+      return cmdLeave(args);
+    case "status":
+      return cmdStatus(args);
+    case "screenshot":
+      return cmdScreenshot(args);
+    case "transcript":
+      return cmdTranscript(args);
+    case "chat":
+      return cmdChat(args);
+    case "frame":
+      return cmdFrame(args);
+    case "dicts":
+      return cmdDicts();
+    case "watch":
+      return cmdWatch();
+    case "_serve":
+      return cmdServe(args);
+    default:
+      throw new ArgError(`invalid choice: '${args.command}'`);
+  }
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h" || argv.includes("--help") || argv.includes("-h")) {
+    process.stdout.write(USAGE);
+    process.exit(argv.length === 0 ? 2 : 0);
+  }
+  let args;
+  try {
+    args = parseArgs(argv);
+  } catch (e) {
+    if (e instanceof ArgError) {
+      process.stderr.write(`samoagent: error: ${e.message}
+`);
+      process.exit(2);
+    }
+    throw e;
+  }
+  try {
+    await dispatch(args);
+  } catch (e) {
+    if (e instanceof ExitError) {
+      process.exit(e.code);
+    }
+    process.stderr.write(`samoagent: error: ${e instanceof Error ? e.message : String(e)}
+`);
+    process.exit(1);
+  }
+}
+if (import.meta.main) {
+  main();
+}
+export {
+  parseArgs
+};