@spekoai/mcp-calls 0.4.5 → 0.4.7

package/dist/index.js

@@ -13,12 +13,12 @@ var __export = (target, all) => {
 import { createHash as createHash2 } from "crypto";
 import { existsSync as existsSync3 } from "fs";
 import { dirname as dirname3, resolve as resolve3 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath4 } from "url";
 function loadDotenv() {
   const load = process.loadEnvFile;
   if (!load)
     return;
-  const here = dirname3(fileURLToPath3(import.meta.url));
+  const here = dirname3(fileURLToPath4(import.meta.url));
   const candidates = [
     resolve3(process.cwd(), ".env"),
     resolve3(process.cwd(), "..", ".env"),
@@ -111,7 +111,7 @@ var init_config = __esm({
 });
 
 // ../server/dist/speko/client.js
-import { Speko, SpekoApiError, SpekoAuthError, SpekoRateLimitError } from "@spekoai/sdk";
+import { Speko as Speko2, SpekoApiError, SpekoAuthError, SpekoRateLimitError } from "@spekoai/sdk";
 function isAuthFailure(e) {
   return e instanceof SpekoAuthError || e instanceof SpekoApiError && (e.status === 401 || e.status === 403);
 }
@@ -127,7 +127,7 @@ var init_client = __esm({
       constructor(cfg) {
         this.apiKey = cfg.speko.apiKey;
         this.baseUrl = (cfg.speko.baseUrl ?? DEFAULT_API_BASE).replace(/\/+$/, "");
-        this.speko = new Speko({
+        this.speko = new Speko2({
           apiKey: cfg.speko.apiKey,
           ...cfg.speko.baseUrl ? { baseUrl: cfg.speko.baseUrl } : {},
           timeout: 3e4
@@ -925,9 +925,9 @@ var init_objective = __esm({
 });
 
 // ../server/dist/safety/prompt.js
-import { randomBytes as randomBytes2 } from "crypto";
+import { randomBytes as randomBytes3 } from "crypto";
 function delimitedBlock(label, content) {
-  const nonce = randomBytes2(8).toString("hex");
+  const nonce = randomBytes3(8).toString("hex");
   return `${BLOCK_RULE} ${label} ${nonce} ${BLOCK_RULE}
 ${content}
 ${BLOCK_RULE} END ${label} ${nonce} ${BLOCK_RULE}`;
@@ -1645,9 +1645,9 @@ function openBrowser(url) {
   if (["1", "true", "yes"].includes((process.env.SPEKO_NO_BROWSER ?? "").toLowerCase())) return;
   try {
     const p = platform();
-    const cmd2 = p === "darwin" ? "open" : p === "win32" ? "cmd" : "xdg-open";
+    const cmd = p === "darwin" ? "open" : p === "win32" ? "cmd" : "xdg-open";
     const args = p === "win32" ? ["/c", "start", "", url] : [url];
-    const child = spawn(cmd2, args, { stdio: "ignore", detached: true });
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
     child.on("error", () => {
     });
     child.unref();
@@ -1872,9 +1872,9 @@ function askSecret(query) {
 function openBrowser2(url) {
   try {
     const p = platform2();
-    const cmd2 = p === "darwin" ? "open" : p === "win32" ? "cmd" : "xdg-open";
+    const cmd = p === "darwin" ? "open" : p === "win32" ? "cmd" : "xdg-open";
     const args = p === "win32" ? ["/c", "start", "", url] : [url];
-    const child = spawn2(cmd2, args, { stdio: "ignore", detached: true });
+    const child = spawn2(cmd, args, { stdio: "ignore", detached: true });
     child.on("error", () => {
     });
     child.unref();
@@ -1983,9 +1983,9 @@ function installSkill() {
     return false;
   }
 }
-async function runInit(argv, mode = "init") {
+async function runInit(argv, mode2 = "init") {
   const f = parseFlags(argv);
-  const quick = mode === "login";
+  const quick = mode2 === "login";
   console.log(c.bold(quick ? "\n  Speko Calls \u2014 sign in\n" : "\n  Speko Calls \u2014 setup\n"));
   if (!quick) {
     console.log("  This MCP places " + c.bold("real, disclosed") + " outbound phone calls to " + c.bold("businesses") + ",");
@@ -2047,6 +2047,14 @@ async function runInit(argv, mode = "init") {
   console.log(c.dim("  set MCP_TIMEOUT=60000 and retry. Re-run this wizard anytime to reconfigure.\n"));
 }
 
+// src/cli/audio/speak.ts
+import { parseArgs } from "util";
+import { statSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolvePath } from "path";
+
+// src/cli/_shared/speko.ts
+import { Speko } from "@spekoai/sdk";
+
 // src/lib/env.ts
 import { existsSync as existsSync2 } from "fs";
 import { dirname as dirname2, resolve as resolve2 } from "path";
@@ -2078,6 +2086,540 @@ function serverEndpoint() {
   return { baseUrl, internalKey };
 }
 
+// src/cli/_shared/speko.ts
+var MissingKeyError = class extends Error {
+  name = "MissingKeyError";
+};
+function resolveApiKey() {
+  const raw = (process.env.SPEKO_API_KEY ?? process.env.SPEKOAI_API_KEY ?? "").trim();
+  return raw.startsWith("Bearer ") ? raw.slice(7) : raw;
+}
+function makeSpeko() {
+  loadEnv();
+  const apiKey = resolveApiKey();
+  if (!apiKey) {
+    throw new MissingKeyError(
+      "SPEKO_API_KEY is not set. Get one at https://platform.speko.dev, then run `npx @spekoai/mcp-calls login` (or export SPEKO_API_KEY=sk_...)."
+    );
+  }
+  return new Speko({ apiKey });
+}
+
+// src/cli/_shared/audio.ts
+function pcmSampleRate(contentType) {
+  const m = /rate=(\d+)/i.exec(contentType);
+  const n = m ? Number(m[1]) : NaN;
+  return Number.isFinite(n) && n > 0 ? n : 24e3;
+}
+function extForContentType(contentType) {
+  const ct = contentType.toLowerCase();
+  if (ct.includes("mpeg") || ct.includes("mp3")) return "mp3";
+  if (ct.includes("wav")) return "wav";
+  if (ct.includes("pcm")) return "wav";
+  if (ct.includes("opus")) return "opus";
+  if (ct.includes("ogg")) return "ogg";
+  if (ct.includes("aac")) return "aac";
+  if (ct.includes("flac")) return "flac";
+  return "audio";
+}
+function pcmToWav(pcm, sampleRate = 24e3) {
+  const header = Buffer.alloc(44);
+  const dataLen = pcm.length;
+  header.write("RIFF", 0);
+  header.writeUInt32LE(36 + dataLen, 4);
+  header.write("WAVE", 8);
+  header.write("fmt ", 12);
+  header.writeUInt32LE(16, 16);
+  header.writeUInt16LE(1, 20);
+  header.writeUInt16LE(1, 22);
+  header.writeUInt32LE(sampleRate, 24);
+  header.writeUInt32LE(sampleRate * 2, 28);
+  header.writeUInt16LE(2, 32);
+  header.writeUInt16LE(16, 34);
+  header.write("data", 36);
+  header.writeUInt32LE(dataLen, 40);
+  return Buffer.concat([header, Buffer.from(pcm)]);
+}
+function toPlayable(audio, contentType) {
+  const ct = contentType.toLowerCase();
+  if (ct.includes("pcm")) {
+    return { bytes: pcmToWav(audio, pcmSampleRate(contentType)), ext: "wav" };
+  }
+  return { bytes: audio, ext: extForContentType(contentType) };
+}
+function guessAudioContentType(pathOrExt) {
+  const ext = pathOrExt.toLowerCase().split(".").pop() ?? "";
+  const map = {
+    wav: "audio/wav",
+    mp3: "audio/mpeg",
+    mpeg: "audio/mpeg",
+    m4a: "audio/mp4",
+    mp4: "audio/mp4",
+    ogg: "audio/ogg",
+    oga: "audio/ogg",
+    opus: "audio/opus",
+    flac: "audio/flac",
+    aac: "audio/aac",
+    webm: "audio/webm"
+  };
+  return map[ext];
+}
+
+// src/cli/_shared/artifact.ts
+import { join as join2 } from "path";
+function resolveOutTarget(a) {
+  const name = `${a.id}.${a.ext}`;
+  if (a.out !== void 0 && a.out !== "") {
+    if (a.outIsDir || a.out.endsWith("/") || a.out.endsWith("\\")) {
+      return { mode: "file", path: join2(a.out, name) };
+    }
+    return { mode: "file", path: a.out };
+  }
+  if (!a.isTTY) return { mode: "stdout" };
+  const dir = a.outputDir && a.outputDir.trim() ? a.outputDir.trim() : a.cwd;
+  return { mode: "file", path: join2(dir, name) };
+}
+
+// src/cli/_shared/io.ts
+import { randomBytes as randomBytes2 } from "crypto";
+function readStreamBytes(stream = process.stdin) {
+  return new Promise((resolve4, reject) => {
+    const chunks = [];
+    stream.on("data", (c2) => chunks.push(Buffer.from(c2)));
+    stream.on("end", () => resolve4(Buffer.concat(chunks)));
+    stream.on("error", reject);
+  });
+}
+async function readStdinText(stream = process.stdin) {
+  return Buffer.from(await readStreamBytes(stream)).toString("utf-8");
+}
+function readStdinBytes(stream = process.stdin) {
+  return readStreamBytes(stream);
+}
+function randomId() {
+  return randomBytes2(4).toString("hex");
+}
+
+// src/cli/_shared/play.ts
+import { spawn as spawn3, spawnSync as spawnSync2 } from "child_process";
+function pickPlayer(platform3, has) {
+  const ffplay = { cmd: "ffplay", args: (f) => ["-nodisp", "-autoexit", "-loglevel", "quiet", f] };
+  if (platform3 === "darwin") {
+    if (has("afplay")) return { cmd: "afplay", args: (f) => [f] };
+    if (has("ffplay")) return ffplay;
+    return null;
+  }
+  if (platform3 === "win32") {
+    if (has("ffplay")) return ffplay;
+    if (has("powershell")) {
+      return {
+        cmd: "powershell",
+        args: (f) => ["-NoProfile", "-Command", `(New-Object Media.SoundPlayer '${f.replace(/'/g, "''")}').PlaySync();`]
+      };
+    }
+    return null;
+  }
+  const candidates = [
+    ["ffplay", ffplay.args],
+    ["mpv", (f) => ["--no-video", "--really-quiet", f]],
+    ["aplay", (f) => [f]],
+    ["paplay", (f) => [f]],
+    ["mpg123", (f) => ["-q", f]]
+  ];
+  for (const [bin, mk] of candidates) {
+    if (has(bin)) return { cmd: bin, args: mk };
+  }
+  return null;
+}
+function onPath(bin) {
+  const probe = process.platform === "win32" ? spawnSync2("where", [bin]) : spawnSync2("which", [bin]);
+  return probe.status === 0;
+}
+async function playFile(path, deps = {}) {
+  const platform3 = deps.platform ?? process.platform;
+  const has = deps.has ?? onPath;
+  const player = pickPlayer(platform3, has);
+  if (!player) return false;
+  await new Promise((resolve4) => {
+    try {
+      const p = spawn3(player.cmd, player.args(path), { stdio: "ignore" });
+      p.on("close", () => resolve4());
+      p.on("error", () => resolve4());
+    } catch {
+      resolve4();
+    }
+  });
+  return true;
+}
+
+// src/cli/audio/speak.ts
+var OPTIMIZE = /* @__PURE__ */ new Set(["balanced", "accuracy", "latency", "cost"]);
+var OPTIONS = {
+  lang: { type: "string" },
+  "optimize-for": { type: "string" },
+  voice: { type: "string" },
+  model: { type: "string" },
+  provider: { type: "string" },
+  speed: { type: "string" },
+  region: { type: "string" },
+  output: { type: "string", short: "o" },
+  format: { type: "string", short: "f" },
+  "no-play": { type: "boolean" },
+  "no-waveform": { type: "boolean" },
+  json: { type: "boolean" },
+  quiet: { type: "boolean", short: "q" }
+};
+async function runSpeak(argv, deps = {}) {
+  const stderr = deps.stderr ?? ((l) => process.stderr.write(l + "\n"));
+  const stdout = deps.stdout ?? process.stdout;
+  let values;
+  let positionals;
+  try {
+    const parsed = parseArgs({ args: argv, options: OPTIONS, allowPositionals: true });
+    values = parsed.values;
+    positionals = parsed.positionals;
+  } catch (e) {
+    stderr(`speak: ${e.message}`);
+    return 2;
+  }
+  const stdinIsTTY = deps.stdinIsTTY ?? Boolean(process.stdin.isTTY);
+  let text = positionals.join(" ").trim();
+  if (!text && !stdinIsTTY) {
+    text = (await (deps.readStdin ?? readStdinText)()).trim();
+  }
+  if (!text) {
+    stderr('speak: no text given. usage: speko audio speak "your text"  (or pipe text via stdin)');
+    return 2;
+  }
+  const optimizeFor = values["optimize-for"];
+  if (optimizeFor && !OPTIMIZE.has(optimizeFor)) {
+    stderr(`speak: --optimize-for must be one of ${[...OPTIMIZE].join(" | ")}`);
+    return 2;
+  }
+  let speed;
+  if (values.speed !== void 0) {
+    speed = Number(values.speed);
+    if (!Number.isFinite(speed) || speed <= 0) {
+      stderr("speak: --speed must be a positive number");
+      return 2;
+    }
+  }
+  const opts = { language: values.lang || "en" };
+  if (optimizeFor) opts.optimizeFor = optimizeFor;
+  if (values.region) opts.region = values.region;
+  if (values.voice) opts.voice = values.voice;
+  if (values.model) opts.model = values.model;
+  if (speed !== void 0) opts.speed = speed;
+  if (values.provider) opts.constraints = { allowedProviders: { tts: [values.provider] } };
+  let speko = deps.speko;
+  if (!speko) {
+    try {
+      speko = makeSpeko();
+    } catch (e) {
+      stderr(e instanceof MissingKeyError ? e.message : `speak: ${e.message}`);
+      return 1;
+    }
+  }
+  let result;
+  try {
+    result = await speko.synthesize(text, opts);
+  } catch (e) {
+    stderr(`speak failed: ${e.message}`);
+    return 1;
+  }
+  const { bytes, ext: derivedExt } = toPlayable(result.audio, result.contentType);
+  const ext = values.format || derivedExt;
+  const routed = `via ${result.provider}:${result.model} \xB7 failover ${result.failoverCount}`;
+  const isTTY = deps.isTTY ?? Boolean(process.stdout.isTTY);
+  let outIsDir = false;
+  if (values.output) {
+    try {
+      outIsDir = statSync(values.output).isDirectory();
+    } catch {
+      outIsDir = false;
+    }
+  }
+  const target = resolveOutTarget({
+    out: values.output,
+    outIsDir,
+    isTTY,
+    ext,
+    id: deps.id ?? randomId(),
+    outputDir: process.env.SPEKO_OUTPUT_DIR,
+    cwd: deps.cwd ?? process.cwd()
+  });
+  if (target.mode === "stdout") {
+    stdout.write(bytes);
+    if (!values.quiet) stderr(routed);
+    return 0;
+  }
+  const path = resolvePath(target.path);
+  (deps.writeFile ?? ((p, b) => writeFileSync2(p, b)))(path, bytes);
+  if (values.json) {
+    stdout.write(
+      JSON.stringify({
+        file: path,
+        provider: result.provider,
+        model: result.model,
+        contentType: result.contentType,
+        failoverCount: result.failoverCount
+      }) + "\n"
+    );
+  } else if (!values.quiet) {
+    stderr(`\u2713 ${path}  (${routed})`);
+  }
+  if (isTTY && !values["no-play"]) {
+    let played = false;
+    try {
+      played = await (deps.play ?? ((p) => playFile(p)))(path);
+    } catch {
+      played = false;
+    }
+    if (!played && !values.quiet) stderr("(no audio player on PATH \u2014 saved the file above)");
+  }
+  return 0;
+}
+
+// src/cli/audio/transcribe.ts
+import { parseArgs as parseArgs2 } from "util";
+import { readFileSync as readFileSync2, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolvePath2 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var OPTIMIZE2 = /* @__PURE__ */ new Set(["balanced", "accuracy", "latency", "cost"]);
+var OPTIONS2 = {
+  lang: { type: "string" },
+  "optimize-for": { type: "string" },
+  "content-type": { type: "string" },
+  keywords: { type: "string" },
+  provider: { type: "string" },
+  output: { type: "string", short: "o" },
+  format: { type: "string", short: "f" },
+  json: { type: "boolean" },
+  quiet: { type: "boolean", short: "q" }
+};
+async function defaultFetch(url) {
+  const r = await fetch(url);
+  if (!r.ok) throw new Error(`fetch ${url} \u2192 HTTP ${r.status}`);
+  return new Uint8Array(await r.arrayBuffer());
+}
+async function runTranscribe(argv, deps = {}) {
+  const stderr = deps.stderr ?? ((l) => process.stderr.write(l + "\n"));
+  const stdout = deps.stdout ?? process.stdout;
+  let values;
+  let positionals;
+  try {
+    const parsed = parseArgs2({ args: argv, options: OPTIONS2, allowPositionals: true });
+    values = parsed.values;
+    positionals = parsed.positionals;
+  } catch (e) {
+    stderr(`transcribe: ${e.message}`);
+    return 2;
+  }
+  const input = positionals[0];
+  const stdinIsTTY = deps.stdinIsTTY ?? Boolean(process.stdin.isTTY);
+  if (!input && stdinIsTTY) {
+    stderr("transcribe: no input. usage: speko audio transcribe <file|url>  (or pipe audio via stdin)");
+    return 2;
+  }
+  const optimizeFor = values["optimize-for"];
+  if (optimizeFor && !OPTIMIZE2.has(optimizeFor)) {
+    stderr(`transcribe: --optimize-for must be one of ${[...OPTIMIZE2].join(" | ")}`);
+    return 2;
+  }
+  let audio;
+  let sourceForCt;
+  try {
+    if (input) {
+      if (/^https?:\/\//i.test(input)) {
+        audio = await (deps.fetchUrl ?? defaultFetch)(input);
+        sourceForCt = input;
+      } else {
+        const path = input.startsWith("file://") ? fileURLToPath3(input) : input;
+        audio = (deps.readFile ?? ((p) => readFileSync2(p)))(path);
+        sourceForCt = path;
+      }
+    } else {
+      audio = await (deps.readStdin ?? readStdinBytes)();
+    }
+  } catch (e) {
+    stderr(`transcribe: could not read audio: ${e.message}`);
+    return 1;
+  }
+  if (!audio || audio.length === 0) {
+    stderr("transcribe: empty audio input");
+    return 2;
+  }
+  const contentType = values["content-type"] || (sourceForCt ? guessAudioContentType(sourceForCt) : void 0);
+  const opts = { language: values.lang || "en" };
+  if (optimizeFor) opts.optimizeFor = optimizeFor;
+  if (contentType) opts.contentType = contentType;
+  if (values.keywords) {
+    const kw = values.keywords.split(",").map((s) => s.trim()).filter(Boolean);
+    if (kw.length) opts.keywords = kw;
+  }
+  if (values.provider) opts.constraints = { allowedProviders: { stt: [values.provider] } };
+  let speko = deps.speko;
+  if (!speko) {
+    try {
+      speko = makeSpeko();
+    } catch (e) {
+      stderr(e instanceof MissingKeyError ? e.message : `transcribe: ${e.message}`);
+      return 1;
+    }
+  }
+  let result;
+  try {
+    result = await speko.transcribe(audio, opts);
+  } catch (e) {
+    stderr(`transcribe failed: ${e.message}`);
+    return 1;
+  }
+  const text = result.text ?? "";
+  const conf = typeof result.confidence === "number" ? ` \xB7 conf ${result.confidence.toFixed(2)}` : "";
+  const routed = `via ${result.provider}:${result.model}${conf} \xB7 failover ${result.failoverCount}`;
+  const isTTY = deps.isTTY ?? Boolean(process.stdout.isTTY);
+  let outIsDir = false;
+  if (values.output) {
+    try {
+      outIsDir = statSync2(values.output).isDirectory();
+    } catch {
+      outIsDir = false;
+    }
+  }
+  const ext = values.format === "md" ? "md" : "txt";
+  const target = resolveOutTarget({
+    out: values.output,
+    outIsDir,
+    isTTY,
+    ext,
+    id: deps.id ?? randomId(),
+    outputDir: process.env.SPEKO_OUTPUT_DIR,
+    cwd: deps.cwd ?? process.cwd()
+  });
+  let writtenPath;
+  if (target.mode === "file" && (Boolean(values.output) || !values.json)) {
+    writtenPath = resolvePath2(target.path);
+    (deps.writeFile ?? ((p, t) => writeFileSync3(p, t)))(writtenPath, text);
+  }
+  if (values.json) {
+    stdout.write(
+      JSON.stringify({
+        text,
+        provider: result.provider,
+        model: result.model,
+        confidence: result.confidence,
+        failoverCount: result.failoverCount,
+        ...writtenPath ? { file: writtenPath } : {}
+      }) + "\n"
+    );
+    return 0;
+  }
+  stdout.write(text.endsWith("\n") ? text : text + "\n");
+  if (writtenPath && !values.quiet) stderr(`\u2713 ${writtenPath}  (${routed})`);
+  else if (!values.quiet) stderr(routed);
+  return 0;
+}
+
+// src/cli/audio/index.ts
+var HELP = 'speko audio \u2014 voice from your terminal (Speko auto-routes to the best provider)\n\nUsage:\n  speko audio speak "<text>" [--voice <id>] [--optimize-for latency|balanced|accuracy|cost]\n                                   [--provider <p>] [--model <m>] [--speed <n>] [--lang <code>]\n                                   [-o <out>] [--format wav|mp3] [--no-play] [--json] [-q]\n  speko audio transcribe <file|url|-> [--lang <code>] [--keywords a,b,c] [--content-type <mime>]\n                                   [--optimize-for ...] [--provider <p>] [-o <out>] [--format txt|md] [--json] [-q]\n\nPipes:\n  echo "ship it" | speko audio speak\n  cat rec.wav | speko audio transcribe\n  speko audio speak "read this back" | speko audio transcribe\n';
+async function runAudio(argv) {
+  const sub = argv[0];
+  if (sub === "speak") return runSpeak(argv.slice(1));
+  if (sub === "transcribe") return runTranscribe(argv.slice(1));
+  if (!sub || sub === "--help" || sub === "-h") {
+    process.stderr.write(HELP);
+    return sub ? 0 : 1;
+  }
+  process.stderr.write(`speko audio: unknown subcommand '${sub}'. try: speak | transcribe
+`);
+  return 2;
+}
+
+// src/cli/voices.ts
+import { parseArgs as parseArgs3 } from "util";
+var OPTIONS3 = {
+  provider: { type: "string" },
+  json: { type: "boolean" },
+  quiet: { type: "boolean", short: "q" }
+};
+async function runVoices(argv, deps = {}) {
+  const stderr = deps.stderr ?? ((l) => process.stderr.write(l + "\n"));
+  const stdout = deps.stdout ?? process.stdout;
+  let values;
+  try {
+    values = parseArgs3({ args: argv, options: OPTIONS3, allowPositionals: false }).values;
+  } catch (e) {
+    stderr(`voices: ${e.message}`);
+    return 2;
+  }
+  let speko = deps.speko;
+  if (!speko) {
+    try {
+      speko = makeSpeko();
+    } catch (e) {
+      stderr(e instanceof MissingKeyError ? e.message : `voices: ${e.message}`);
+      return 1;
+    }
+  }
+  let result;
+  try {
+    result = await speko.voices.list(values.provider ? { provider: values.provider } : {});
+  } catch (e) {
+    stderr(`voices failed: ${e.message}`);
+    return 1;
+  }
+  if (values.json) {
+    stdout.write(JSON.stringify(result) + "\n");
+    return 0;
+  }
+  const providers = result.providers ?? [];
+  const voices = result.voices ?? [];
+  const lines = [];
+  if (providers.length) {
+    lines.push("Providers (the router auto-picks the best per --optimize-for):");
+    for (const p of providers) {
+      const models = p.models?.length ? p.models.join(", ") : "-";
+      const note = p.voicesFetchedLive ? "  (voices are account-scoped \u2014 pass --voice <id>)" : "";
+      lines.push(`  ${p.key.padEnd(14)} ${p.name}${note}`);
+      lines.push(`  ${" ".repeat(14)} models: ${models}`);
+    }
+    lines.push("");
+  }
+  if (voices.length) {
+    lines.push(`Voices (${voices.length}):`);
+    lines.push(`  ${"vendor".padEnd(14)} ${"id".padEnd(28)} name`);
+    for (const v of voices) {
+      lines.push(`  ${v.vendor.padEnd(14)} ${v.id.padEnd(28)} ${v.name}`);
+    }
+  } else {
+    lines.push("No standalone voice ids returned (ElevenLabs voices are account-scoped \u2014 pass --voice <id> to speak).");
+  }
+  stdout.write(lines.join("\n") + "\n");
+  return 0;
+}
+
+// src/cli/router.ts
+var CLI_COMMANDS = [
+  "init",
+  "setup",
+  "login",
+  "audio",
+  "voices",
+  "models",
+  "--help",
+  "-h",
+  "--version",
+  "-V"
+];
+function resolveMode(argv, opts = {}) {
+  const cmd = argv[2];
+  if (cmd && CLI_COMMANDS.includes(cmd)) {
+    return { kind: "cli", name: cmd };
+  }
+  if (opts.stdinIsTTY) return { kind: "help" };
+  return { kind: "server" };
+}
+
 // src/tools/CallMeTool.ts
 import { MCPTool } from "mcp-framework";
 import { z } from "zod";
@@ -2108,7 +2650,7 @@ import { MCPTool as MCPTool2 } from "mcp-framework";
 import { z as z2 } from "zod";
 
 // src/http/serverClient.ts
-import { randomBytes as randomBytes3 } from "crypto";
+import { randomBytes as randomBytes4 } from "crypto";
 var DemoServerError = class extends Error {
   name = "DemoServerError";
 };
@@ -2178,7 +2720,7 @@ var InProcessBackend = class {
     if (!this.ready) {
       this.ready = (async () => {
         if (!(process.env.SPEKO_DIAL_TOKEN_SECRET ?? "").trim()) {
-          process.env.SPEKO_DIAL_TOKEN_SECRET = randomBytes3(32).toString("hex");
+          process.env.SPEKO_DIAL_TOKEN_SECRET = randomBytes4(32).toString("hex");
         }
         const core = await Promise.resolve().then(() => (init_core(), core_exports));
         const cfg = core.loadConfig();
@@ -2586,15 +3128,58 @@ var MakeCallTool = class extends MCPTool6 {
 };
 
 // src/index.ts
-var cmd = process.argv[2];
-if (cmd === "init" || cmd === "setup" || cmd === "login") {
-  await runInit(process.argv.slice(3), cmd);
+var VERSION = "0.4.7";
+function printHelp() {
+  process.stderr.write(
+    `speko ${VERSION} \u2014 call real businesses + speak/transcribe from your terminal; also an MCP server for coding agents.
+
+Usage:
+  speko                          (when launched by an MCP host) the stdio MCP server
+  speko init | setup | login     onboarding & auth
+  speko audio speak "<text>"     text-to-speech (TTS)
+  speko audio transcribe <f|->   speech-to-text (STT)
+  speko voices [--provider <p>]  list available voices
+  speko --help | --version
+`
+  );
+  return 0;
+}
+function printVersion() {
+  process.stdout.write(VERSION + "\n");
+  return 0;
+}
+var rest = process.argv.slice(3);
+var CLI = {
+  init: async () => (await runInit(rest, "init"), 0),
+  setup: async () => (await runInit(rest, "setup"), 0),
+  login: async () => (await runInit(rest, "login"), 0),
+  audio: () => runAudio(rest),
+  voices: () => runVoices(rest),
+  models: () => runVoices(rest),
+  "--help": printHelp,
+  "-h": printHelp,
+  "--version": printVersion,
+  "-V": printVersion
+};
+var mode = resolveMode(process.argv, { stdinIsTTY: Boolean(process.stdin.isTTY) });
+if (mode.kind === "cli") {
+  try {
+    const code = await CLI[mode.name]();
+    process.exit(typeof code === "number" ? code : 0);
+  } catch (e) {
+    process.stderr.write(`${mode.name}: ${e.message}
+`);
+    process.exit(1);
+  }
+}
+if (mode.kind === "help") {
+  printHelp();
   process.exit(0);
 }
 loadEnv();
 var server = new MCPServer({
   name: "speko-calls",
-  version: "0.4.5",
+  version: VERSION,
   transport: { type: "stdio" }
 });
 server.addTool(LookupBusinessTool);