recmp3-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1960 @@
+#!/usr/bin/env node
+import { setSecret, keychainAvailable } from './chunk-FNZ6ZCOK.js';
+import { loadConfig, providerUploads, createProvider, configFilePath, getApiKey, RecmpConfigSchema, paths, saveConfig, resetConfigCache } from './chunk-XGHYROLT.js';
+import './chunk-NY5EJT5D.js';
+import { initLogger, redactKey, log } from './chunk-DDXRBIWU.js';
+import { checkFfmpegVersion, supportsInputFormat, findFfmpeg } from './chunk-7NR5CU7W.js';
+import { ExitCode, RecmpError, InputError, ConfigError, AudioCaptureError } from './chunk-NUWDWBJQ.js';
+import { Command } from 'commander';
+import pc2 from 'picocolors';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { existsSync, readFileSync } from 'fs';
+import { mkdtemp, writeFile, rm, mkdir, stat, readdir } from 'fs/promises';
+import { join, basename, dirname } from 'path';
+import { createInterface } from 'readline';
+import { randomBytes } from 'crypto';
+import { tmpdir } from 'os';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { render, useApp, useInput, Box, Text } from 'ink';
+import { useState, useRef, useEffect, useCallback } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+var SCHEMA_VERSION = 1;
+var HumanSink = class {
+  ok(_command, _payload, humanRender) {
+    if (humanRender) humanRender();
+  }
+  fail(error, _command) {
+    process.stderr.write(`
+${pc2.red("\u2717")} ${error.message}
+
+`);
+  }
+};
+var JsonSink = class {
+  ok(command, payload) {
+    const envelope = {
+      ok: true,
+      command,
+      schemaVersion: SCHEMA_VERSION,
+      data: payload
+    };
+    process.stdout.write(`${JSON.stringify(envelope, null, 2)}
+`);
+  }
+  fail(error, command) {
+    const envelope = {
+      ok: false,
+      command,
+      schemaVersion: SCHEMA_VERSION,
+      error
+    };
+    process.stdout.write(`${JSON.stringify(envelope, null, 2)}
+`);
+  }
+};
+var CaptureSink = class {
+  envelope = null;
+  ok(command, payload) {
+    this.envelope = {
+      ok: true,
+      command,
+      schemaVersion: SCHEMA_VERSION,
+      data: payload
+    };
+  }
+  fail(error, command) {
+    this.envelope = {
+      ok: false,
+      command,
+      schemaVersion: SCHEMA_VERSION,
+      error
+    };
+  }
+};
+function toErrorPayload(err) {
+  if (err instanceof RecmpError) {
+    return { code: err.code, message: err.message, exitCode: err.exitCode };
+  }
+  if (err instanceof Error) {
+    return {
+      code: "UNEXPECTED_ERROR",
+      message: err.message,
+      exitCode: ExitCode.UNKNOWN
+    };
+  }
+  return {
+    code: "UNKNOWN_ERROR",
+    message: String(err),
+    exitCode: ExitCode.UNKNOWN
+  };
+}
+
+// src/agent/context.ts
+var AgentContext = class _AgentContext {
+  json;
+  yes;
+  quiet;
+  color;
+  sink;
+  constructor(opts = {}) {
+    this.json = opts.json ?? false;
+    this.yes = opts.yes ?? false;
+    this.quiet = opts.quiet ?? false;
+    this.color = opts.color ?? true;
+    this.sink = opts.sink ?? (this.json ? new JsonSink() : new HumanSink());
+  }
+  /** Build the context from resolved global option values + environment. */
+  static fromGlobals(opts) {
+    const json = Boolean(opts.json) || process.env.RECMP3_JSON === "1";
+    const yes = Boolean(opts.yes) || process.env.RECMP3_YES === "1" || process.env.RECMP3_SKIP_CONSENT === "1";
+    const quiet = Boolean(opts.quiet) || process.env.RECMP3_QUIET === "1";
+    const color = opts.color !== false && !process.env.NO_COLOR && process.stdout.isTTY !== false;
+    return new _AgentContext({
+      json,
+      yes,
+      quiet,
+      color,
+      sink: json ? new JsonSink() : new HumanSink()
+    });
+  }
+  /** Context for MCP tool calls: captured JSON, prompts auto-skipped, no chatter. */
+  static forCapture() {
+    return new _AgentContext({
+      json: true,
+      yes: true,
+      quiet: true,
+      color: false,
+      sink: new CaptureSink()
+    });
+  }
+  /** Emit a successful result. `humanRender` runs only in human (non-json) mode. */
+  ok(command, payload, humanRender) {
+    this.sink.ok(command, payload, humanRender);
+  }
+  /** Emit a failure envelope. Does not exit — the caller controls process exit. */
+  fail(err, command) {
+    this.sink.fail(toErrorPayload(err), command);
+  }
+  /** Write progress/diagnostic chatter to stderr unless quiet. */
+  note(text) {
+    if (!this.quiet) process.stderr.write(text);
+  }
+};
+
+// src/agent/stdin.ts
+async function readStdinBuffer() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks);
+}
+async function readStdinText() {
+  return (await readStdinBuffer()).toString("utf-8");
+}
+
+// src/commands/config.ts
+var ENV_VAR = {
+  groq: "GROQ_API_KEY",
+  openai: "OPENAI_API_KEY"
+};
+async function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+    rl.once("close", () => resolve(""));
+  });
+}
+async function confirm(question, defaultYes = true) {
+  const hint = defaultYes ? "[Y/n]" : "[y/N]";
+  const answer = await prompt(`${question} ${hint} `);
+  if (!answer) return defaultYes;
+  return answer.toLowerCase().startsWith("y");
+}
+async function runConfigInit(opts, ctx2) {
+  const flagDriven = Boolean(
+    opts.provider || opts.lang || opts.outdir || opts.key
+  );
+  const interactive = !flagDriven && !ctx2.yes && process.stdout.isTTY === true && !ctx2.json;
+  if (interactive) {
+    return runConfigInitInteractive();
+  }
+  const providerName = ["groq", "openai", "local-whisper"].includes(opts.provider ?? "") ? opts.provider : "groq";
+  const config = RecmpConfigSchema.parse({});
+  config.provider.default = providerName;
+  if (opts.lang) config.transcription.defaultLanguage = opts.lang;
+  config.output.recordingDir = opts.outdir ?? paths.recordings;
+  await mkdir(dirname(configFilePath), { recursive: true });
+  await mkdir(config.output.recordingDir, { recursive: true });
+  await saveConfig(config);
+  let keychainStored = false;
+  if (opts.key && (providerName === "groq" || providerName === "openai")) {
+    keychainStored = await setSecret(ENV_VAR[providerName], opts.key);
+    if (!keychainStored) {
+      ctx2.note(
+        pc2.yellow(
+          "  OS keychain unavailable \u2014 set the key via env var instead.\n"
+        )
+      );
+    }
+  }
+  ctx2.ok(
+    "config init",
+    {
+      configPath: configFilePath,
+      provider: providerName,
+      recordingDir: config.output.recordingDir,
+      keychainStored
+    },
+    () => {
+      console.log(`${pc2.green("\u2713")} Config saved: ${configFilePath}`);
+      console.log(`${pc2.green("\u2713")} Provider: ${providerName}`);
+      if (keychainStored)
+        console.log(`${pc2.green("\u2713")} API key stored in OS keychain`);
+    }
+  );
+}
+async function runConfigInitInteractive() {
+  console.log(`
+${pc2.bold("recmp3 \u2014 First-time setup")}`);
+  console.log(pc2.gray(`Config will be saved to: ${configFilePath}
+`));
+  console.log(`${pc2.bold("1. Transcription provider")}`);
+  console.log(
+    `   ${pc2.cyan("groq")}   \u2014 Groq Whisper API (fast, cheap, recommended)`
+  );
+  console.log(`   ${pc2.cyan("openai")} \u2014 OpenAI Whisper API`);
+  console.log(`   ${pc2.cyan("local-whisper")} \u2014 local whisper.cpp (no upload)`);
+  const providerInput = await prompt("\n   Choice [groq]: ");
+  const providerName = ["groq", "openai", "local-whisper"].includes(providerInput) ? providerInput : "groq";
+  console.log(`
+${pc2.bold("2. API key")}`);
+  if (providerName === "local-whisper") {
+    console.log(
+      `   ${pc2.gray("No API key needed. Set RECMP3_WHISPER_BIN and RECMP3_WHISPER_MODEL.")}`
+    );
+  } else {
+    const envVar = ENV_VAR[providerName];
+    const existingKey = await getApiKey(providerName);
+    if (existingKey) {
+      console.log(
+        `   ${pc2.green("\u2713")} ${envVar} is already set: ${redactKey(existingKey)}`
+      );
+    } else {
+      const entered = await prompt(
+        `   Paste ${envVar} (stored in OS keychain), or leave blank: `
+      );
+      if (entered) {
+        const stored = await setSecret(envVar, entered);
+        console.log(
+          stored ? `   ${pc2.green("\u2713")} Stored in OS keychain` : `   ${pc2.yellow("!")} Keychain unavailable \u2014 set ${envVar} as an env var.`
+        );
+      } else {
+        const ok = await confirm(
+          "   Continue without setting the key for now?",
+          true
+        );
+        if (!ok) {
+          console.log(
+            pc2.gray("\n  Setup cancelled. Re-run after setting the API key.\n")
+          );
+          return;
+        }
+      }
+    }
+  }
+  console.log(`
+${pc2.bold("3. Default language")}`);
+  const lang = await prompt("   Language code (e.g. es, en) [auto]: ");
+  console.log(`
+${pc2.bold("4. Recordings directory")}`);
+  console.log(`   ${pc2.gray(`Default: ${paths.recordings}`)}`);
+  const outDir = await prompt("   Directory [default]: ");
+  const config = RecmpConfigSchema.parse({});
+  config.provider.default = providerName;
+  if (lang) config.transcription.defaultLanguage = lang;
+  config.output.recordingDir = outDir || paths.recordings;
+  await mkdir(dirname(configFilePath), { recursive: true });
+  await mkdir(config.output.recordingDir, { recursive: true });
+  await saveConfig(config);
+  console.log(`
+${pc2.green("\u2713")} Config saved: ${configFilePath}`);
+  console.log(
+    `${pc2.green("\u2713")} Recordings directory: ${config.output.recordingDir}`
+  );
+  console.log(`
+  ${pc2.cyan("recmp3 doctor")}  \u2014 verify setup
+`);
+}
+async function runConfigShow(ctx2) {
+  const config = await loadConfig();
+  const groqKey = await getApiKey("groq");
+  const openaiKey = await getApiKey("openai");
+  const payload = {
+    configPath: existsSync(configFilePath) ? configFilePath : null,
+    provider: {
+      default: config.provider.default,
+      groqModel: config.provider.groq?.model ?? "whisper-large-v3-turbo",
+      openaiModel: config.provider.openai?.model ?? "whisper-1",
+      local: config.provider.local ?? null
+    },
+    keys: {
+      groq: groqKey ? redactKey(groqKey) : null,
+      openai: openaiKey ? redactKey(openaiKey) : null
+    },
+    audio: config.audio,
+    output: config.output,
+    transcription: config.transcription
+  };
+  ctx2.ok("config show", payload, () => {
+    console.log(`
+${pc2.bold("recmp3 configuration")}`);
+    console.log(
+      pc2.gray(
+        `Config file: ${payload.configPath ?? `${configFilePath} (not found \u2014 using defaults)`}
+`
+      )
+    );
+    console.log(`${pc2.bold("Provider")}`);
+    console.log(`  default:     ${pc2.cyan(config.provider.default)}`);
+    console.log(`  groq model:  ${payload.provider.groqModel}`);
+    console.log(`  openai model:${payload.provider.openaiModel}`);
+    console.log(`
+${pc2.bold("API keys")}`);
+    console.log(
+      `  GROQ_API_KEY:   ${groqKey ? pc2.green(`set (${redactKey(groqKey)})`) : pc2.red("not set")}`
+    );
+    console.log(
+      `  OPENAI_API_KEY: ${openaiKey ? pc2.green(`set (${redactKey(openaiKey)})`) : pc2.gray("not set")}`
+    );
+    console.log(`
+${pc2.bold("Audio")}`);
+    console.log(`  source:      ${config.audio.source}`);
+    console.log(`
+${pc2.bold("Output")}`);
+    console.log(`  recordingDir: ${config.output.recordingDir}`);
+    console.log(`
+${pc2.bold("Transcription")}`);
+    console.log(
+      `  language:    ${config.transcription.defaultLanguage ?? "auto-detect"}
+`
+    );
+  });
+}
+async function runConfigPath(ctx2) {
+  ctx2.ok(
+    "config path",
+    { path: configFilePath },
+    () => console.log(configFilePath)
+  );
+}
+async function runConfigSet(key, value, ctx2) {
+  const config = await loadConfig();
+  const parts = key.split(".");
+  let obj = config;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (typeof obj[part] !== "object" || obj[part] === null) obj[part] = {};
+    obj = obj[part];
+  }
+  const lastKey = parts[parts.length - 1];
+  if (value === "true") obj[lastKey] = true;
+  else if (value === "false") obj[lastKey] = false;
+  else if (!Number.isNaN(Number(value))) obj[lastKey] = Number(value);
+  else obj[lastKey] = value;
+  const parsed = RecmpConfigSchema.safeParse(config);
+  if (!parsed.success) {
+    throw new ConfigError(`Invalid config value: ${parsed.error.message}`);
+  }
+  await saveConfig(parsed.data);
+  resetConfigCache();
+  ctx2.ok(
+    "config set",
+    { key, value },
+    () => console.log(`${pc2.green("\u2713")} Set ${key} = ${value}`)
+  );
+}
+async function runConfigSetKey(provider, opts, ctx2) {
+  if (provider !== "groq" && provider !== "openai") {
+    throw new InputError(
+      `Unknown provider: "${provider}". Valid: groq, openai.`
+    );
+  }
+  let value = opts.key;
+  if (!value && process.stdin.isTTY !== true) {
+    value = (await readStdinText()).trim();
+  }
+  if (!value) value = process.env[ENV_VAR[provider]];
+  if (!value) {
+    throw new InputError(
+      "No key provided. Use --key, pipe it on stdin, or set the *_API_KEY env var."
+    );
+  }
+  if (!await keychainAvailable()) {
+    throw new ConfigError(
+      "OS keychain (keytar) is unavailable on this machine."
+    );
+  }
+  await setSecret(ENV_VAR[provider], value);
+  ctx2.ok(
+    "config set-key",
+    { provider, stored: true, backend: "keychain" },
+    () => console.log(
+      `${pc2.green("\u2713")} Stored ${ENV_VAR[provider]} in the OS keychain (${redactKey(value)})`
+    )
+  );
+}
+function printCheck(check) {
+  const icon = check.ok ? pc2.green("\u2713") : pc2.red("\u2717");
+  const label = pc2.bold(check.label.padEnd(30));
+  const detail = check.detail ? pc2.gray(check.detail) : "";
+  console.log(`  ${icon} ${label} ${detail}`);
+  if (!check.ok && check.hint) {
+    console.log(`    ${pc2.yellow("\u2192")} ${pc2.yellow(check.hint)}`);
+  }
+}
+async function runDoctor(ctx2) {
+  const checks = [];
+  const nodeVersion = process.version;
+  const [nodeMajor] = nodeVersion.slice(1).split(".").map(Number);
+  const nodeOk = nodeMajor >= 20;
+  checks.push({
+    label: "Node.js version",
+    ok: nodeOk,
+    detail: nodeVersion,
+    hint: nodeOk ? void 0 : "Requires Node.js 20+. Visit https://nodejs.org/"
+  });
+  const platform = process.platform;
+  const platformLabels = {
+    linux: "Linux",
+    darwin: "macOS",
+    win32: "Windows"
+  };
+  const platformLabel = platformLabels[platform] ?? platform;
+  const platformSupported = ["linux", "darwin", "win32"].includes(platform);
+  checks.push({
+    label: "Platform",
+    ok: platformSupported,
+    detail: `${platformLabel} (${process.arch})`,
+    hint: platformSupported ? void 0 : `Platform "${platform}" may not be fully supported.`
+  });
+  const ffmpegCheck = await checkFfmpegVersion();
+  checks.push({
+    label: "ffmpeg",
+    ok: ffmpegCheck.meets,
+    detail: ffmpegCheck.version,
+    hint: ffmpegCheck.meets ? void 0 : "Requires ffmpeg 4.4+. Install: sudo apt install ffmpeg"
+  });
+  if (ffmpegCheck.meets) {
+    const backendFormats = {
+      linux: "pulse",
+      darwin: "avfoundation",
+      win32: "dshow"
+    };
+    const backendFormat = backendFormats[platform] ?? "pulse";
+    const backendOk = await supportsInputFormat(backendFormat).catch(
+      () => false
+    );
+    checks.push({
+      label: "Audio backend",
+      ok: backendOk,
+      detail: backendFormat,
+      hint: backendOk ? void 0 : `ffmpeg missing "${backendFormat}" input support. Reinstall ffmpeg.`
+    });
+  }
+  const configExists = existsSync(configFilePath);
+  checks.push({
+    label: "Config file",
+    ok: true,
+    detail: configExists ? configFilePath : `${configFilePath} (using defaults)`
+  });
+  let config;
+  try {
+    config = await loadConfig();
+  } catch (err) {
+    checks.push({
+      label: "Config load",
+      ok: false,
+      detail: err instanceof Error ? err.message : String(err),
+      hint: "Run: recmp3 config init"
+    });
+  }
+  if (config) {
+    const providerName = config.provider.default;
+    if (providerName === "local-whisper") {
+      const { LocalWhisperProvider } = await import('./local-whisper-VH26RX7Y.js');
+      const provider = new LocalWhisperProvider(config.provider.local ?? {});
+      const ping = await provider.ping();
+      checks.push({
+        label: "Provider: local-whisper",
+        ok: ping.ok,
+        detail: ping.ok ? `ready (${ping.latencyMs}ms)` : ping.error,
+        hint: ping.ok ? void 0 : "Set RECMP3_WHISPER_BIN and RECMP3_WHISPER_MODEL."
+      });
+    } else {
+      const apiKey = await getApiKey(providerName);
+      const keyOk = Boolean(apiKey);
+      checks.push({
+        label: `Provider: ${providerName}`,
+        ok: keyOk,
+        detail: keyOk ? `API key set (${redactKey(apiKey)})` : "API key not set",
+        hint: keyOk ? void 0 : `Set ${providerName === "groq" ? "GROQ_API_KEY" : "OPENAI_API_KEY"}, or run: recmp3 config set-key ${providerName}`
+      });
+      if (keyOk) {
+        try {
+          const { createProvider: createProvider2 } = await import('./registry-D5SOVUEJ.js');
+          const provider = await createProvider2(config);
+          const ping = provider.ping ? await provider.ping() : null;
+          if (ping) {
+            checks.push({
+              label: "Provider ping",
+              ok: ping.ok,
+              detail: ping.ok ? `${ping.latencyMs}ms` : ping.error,
+              hint: ping.ok ? void 0 : "Check network connection or API key validity."
+            });
+          }
+        } catch (err) {
+          checks.push({
+            label: "Provider ping",
+            ok: false,
+            detail: err instanceof Error ? err.message : String(err),
+            hint: "Check network connectivity."
+          });
+        }
+      }
+    }
+    checks.push({
+      label: "Recordings directory",
+      ok: true,
+      detail: config.output.recordingDir
+    });
+  }
+  const allOk = checks.every((c) => c.ok);
+  ctx2.ok("doctor", { ok: allOk, checks }, () => {
+    console.log(`
+${pc2.bold("recmp3 doctor \u2014 preflight checks")}
+`);
+    for (const check of checks) printCheck(check);
+    console.log("");
+    if (allOk) {
+      console.log(
+        pc2.green("  \u2713 All checks passed. Run: recmp3 record --transcribe\n")
+      );
+    } else {
+      console.log(
+        pc2.yellow(
+          "  Some checks failed. Address the issues above and re-run: recmp3 doctor\n"
+        )
+      );
+    }
+  });
+  if (!allOk) process.exitCode = 1;
+}
+
+// src/agent/manifest.ts
+var GLOBAL_FLAGS = [
+  {
+    name: "--json",
+    type: "boolean",
+    description: "Emit a stable JSON envelope on stdout",
+    env: "RECMP3_JSON"
+  },
+  {
+    name: "--yes",
+    type: "boolean",
+    description: "Skip all interactive prompts",
+    env: "RECMP3_YES"
+  },
+  {
+    name: "--quiet",
+    type: "boolean",
+    description: "Suppress stderr chatter",
+    env: "RECMP3_QUIET"
+  },
+  {
+    name: "--no-color",
+    type: "boolean",
+    description: "Disable colored output",
+    env: "NO_COLOR"
+  }
+];
+var MANIFEST = {
+  name: "recmp3",
+  version: "1.0.0",
+  description: "Record audio, transcribe with AI, output developer-ready prompts.",
+  globalFlags: GLOBAL_FLAGS,
+  exitCodes: {
+    success: ExitCode.SUCCESS,
+    unknown: ExitCode.UNKNOWN,
+    config: ExitCode.CONFIG,
+    audio: ExitCode.AUDIO,
+    transcription: ExitCode.TRANSCRIPTION,
+    network: ExitCode.NETWORK,
+    localWhisper: ExitCode.LOCAL_WHISPER,
+    input: ExitCode.INPUT,
+    userAbort: ExitCode.USER_ABORT
+  },
+  commands: [
+    {
+      name: "transcribe",
+      tool: "recmp3_transcribe",
+      summary: "Transcribe an existing audio file.",
+      agentSafe: true,
+      args: [
+        {
+          name: "file",
+          required: true,
+          description: 'Audio file path, or "-" for stdin'
+        }
+      ],
+      flags: [
+        {
+          name: "--provider",
+          type: "string",
+          description: "groq | openai | local-whisper"
+        },
+        {
+          name: "--lang",
+          type: "string",
+          description: "Force language code (e.g. es, en)"
+        },
+        {
+          name: "--copy",
+          type: "boolean",
+          description: "Copy transcript to clipboard"
+        }
+      ],
+      stdin: true,
+      stdout: "json"
+    },
+    {
+      name: "prompt",
+      tool: "recmp3_prompt",
+      summary: "Wrap a transcript in a developer prompt template (no network).",
+      agentSafe: true,
+      args: [
+        {
+          name: "file",
+          required: true,
+          description: 'Transcript file path, or "-" for stdin'
+        }
+      ],
+      flags: [
+        {
+          name: "--template",
+          type: "string",
+          description: "claude-code | prd | bug | todo | meeting-notes | commit-message | raw",
+          default: "claude-code"
+        },
+        {
+          name: "--out",
+          type: "string",
+          description: "Write output to a file"
+        },
+        {
+          name: "--copy",
+          type: "boolean",
+          description: "Copy output to clipboard"
+        }
+      ],
+      stdin: true,
+      stdout: "json"
+    },
+    {
+      name: "sources",
+      tool: "recmp3_sources",
+      summary: "List available audio input sources for the OS.",
+      agentSafe: true,
+      flags: [],
+      stdin: false,
+      stdout: "json"
+    },
+    {
+      name: "doctor",
+      tool: "recmp3_doctor",
+      summary: "Run preflight checks (Node, ffmpeg, audio backend, provider, etc.).",
+      agentSafe: true,
+      flags: [],
+      stdin: false,
+      stdout: "json"
+    },
+    {
+      name: "config show",
+      tool: "recmp3_config_show",
+      summary: "Show resolved configuration (API keys redacted).",
+      agentSafe: true,
+      flags: [],
+      stdin: false,
+      stdout: "json"
+    },
+    {
+      name: "manifest",
+      tool: "recmp3_manifest",
+      summary: "Print the command/tool manifest.",
+      agentSafe: true,
+      flags: [],
+      stdin: false,
+      stdout: "json"
+    },
+    {
+      name: "record",
+      tool: "recmp3_record",
+      summary: "Record audio. Agent/headless mode requires --duration.",
+      agentSafe: true,
+      flags: [
+        {
+          name: "--duration",
+          type: "number",
+          description: "Headless: record N seconds then stop"
+        },
+        { name: "--name", type: "string", description: "Output filename stem" },
+        { name: "--out", type: "string", description: "Output directory" },
+        {
+          name: "--transcribe",
+          type: "boolean",
+          description: "Transcribe after recording"
+        },
+        {
+          name: "--provider",
+          type: "string",
+          description: "groq | openai | local-whisper"
+        },
+        { name: "--lang", type: "string", description: "Force language code" },
+        {
+          name: "--source",
+          type: "string",
+          description: 'Audio source id, or "auto" for the best physical mic'
+        }
+      ],
+      stdin: false,
+      stdout: "json"
+    },
+    {
+      name: "config init",
+      summary: "First-time setup. Flag-driven when non-interactive.",
+      agentSafe: false,
+      flags: [
+        {
+          name: "--provider",
+          type: "string",
+          description: "groq | openai | local-whisper"
+        },
+        {
+          name: "--lang",
+          type: "string",
+          description: "Default language code"
+        },
+        {
+          name: "--outdir",
+          type: "string",
+          description: "Recordings output directory"
+        },
+        {
+          name: "--key",
+          type: "string",
+          description: "API key to store in the OS keychain"
+        }
+      ],
+      stdin: false,
+      stdout: "none"
+    },
+    {
+      name: "config set-key",
+      summary: "Store an API key in the OS keychain.",
+      agentSafe: false,
+      args: [
+        { name: "provider", required: true, description: "groq | openai" }
+      ],
+      flags: [
+        {
+          name: "--key",
+          type: "string",
+          description: "Key value (else stdin or *_API_KEY env)"
+        }
+      ],
+      stdin: true,
+      stdout: "none"
+    },
+    {
+      name: "mcp",
+      summary: "Start the Model Context Protocol server over stdio.",
+      agentSafe: false,
+      flags: [],
+      stdin: true,
+      stdout: "none"
+    }
+  ]
+};
+
+// src/commands/manifest.ts
+async function runManifest(ctx2) {
+  ctx2.ok("manifest", MANIFEST, () => {
+    process.stdout.write(`${JSON.stringify(MANIFEST, null, 2)}
+`);
+  });
+}
+
+// src/output/clipboard.ts
+async function copyToClipboard(text) {
+  try {
+    const clipboardy = await import('clipboardy');
+    await clipboardy.default.write(text);
+    return true;
+  } catch (err) {
+    log.info(
+      `Clipboard copy failed (headless or missing xclip/wl-copy): ${err instanceof Error ? err.message : String(err)}`
+    );
+    return false;
+  }
+}
+
+// src/commands/prompt.ts
+var TEMPLATES = {
+  raw: (text) => text,
+  "claude-code": (text, name) => `# Claude Code Prompt${name ? ` \u2014 ${name}` : ""}
+
+## Objective
+${text}
+
+## Context
+[Add relevant codebase context here]
+
+## Scope
+- In scope: [define boundaries]
+- Out of scope: [define exclusions]
+
+## Constraints
+- [Technical constraints]
+- [Time constraints]
+
+## Acceptance Criteria
+- [ ] [Add specific acceptance criteria]
+- [ ] All existing tests pass
+- [ ] No regressions introduced
+
+## Verification
+\`\`\`bash
+# Add verification commands here
+\`\`\`
+
+## CKIS writeback suggestion
+[Note any architectural decisions made during implementation]
+`,
+  prd: (text, name) => `# Product Requirements Document${name ? ` \u2014 ${name}` : ""}
+
+**Created:** ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+**Status:** Draft
+
+## Problem Statement
+${text}
+
+## Goals
+- [Primary goal]
+- [Secondary goal]
+
+## Non-Goals
+- [What this does NOT address]
+
+## User Stories
+- As a [user], I want [feature] so that [benefit]
+
+## Requirements
+### Functional
+- [ ] [Requirement 1]
+
+### Non-Functional
+- [ ] [Performance requirement]
+- [ ] [Security requirement]
+
+## Success Metrics
+- [Metric 1]
+
+## Open Questions
+- [Question 1]
+
+## Timeline
+- [Milestone]: [Date]
+`,
+  bug: (text, name) => `# Bug Report${name ? ` \u2014 ${name}` : ""}
+
+**Date:** ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+**Severity:** [critical / high / medium / low]
+
+## Description
+${text}
+
+## Steps to Reproduce
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+
+## Expected Behavior
+[What should happen]
+
+## Actual Behavior
+[What actually happens]
+
+## Environment
+- OS: ${process.platform}
+- Node: ${process.version}
+
+## Possible Fix
+[Your hypothesis]
+
+## Attachments
+- [ ] Screenshots
+- [ ] Logs
+- [ ] Reproduction repo
+`,
+  "meeting-notes": (text, name) => `# Meeting Notes${name ? ` \u2014 ${name}` : ""}
+
+**Date:** ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+
+## Summary
+${text}
+
+## Action Items
+- [ ] [Owner] \u2014 [Action] \u2014 [Due date]
+
+## Decisions Made
+- [Decision 1]
+
+## Open Questions
+- [Question 1]
+
+## Next Meeting
+- [ ] Schedule: [Date/Time]
+`,
+  todo: (text) => {
+    const lines = text.split(/[.!?]+/).filter((l) => l.trim().length > 5);
+    const todos = lines.map((l) => `- [ ] ${l.trim()}`).join("\n");
+    return `# TODO List
+
+${todos}
+`;
+  },
+  "commit-message": (text) => {
+    const firstSentence = text.split(/[.!?]/)[0]?.trim() ?? text;
+    const subject = firstSentence.slice(0, 72).toLowerCase().replace(/^i /, "");
+    const body = text.length > firstSentence.length ? `
+
+${text}` : "";
+    return `${subject}${body}
+`;
+  }
+};
+function listTemplates() {
+  console.log(`
+${pc2.bold("Available prompt templates:")}
+`);
+  for (const name of Object.keys(TEMPLATES)) {
+    console.log(`  ${pc2.cyan(name)}`);
+  }
+  console.log(
+    "\n  Usage: recmp3 prompt <transcript.txt> --template claude-code\n"
+  );
+}
+async function runPrompt(transcriptFile, opts, ctx2) {
+  if (opts.listTemplates) {
+    listTemplates();
+    return;
+  }
+  const templateName = opts.template ?? "claude-code";
+  const templateFn = TEMPLATES[templateName];
+  if (!templateFn) {
+    throw new InputError(
+      `Unknown template: "${templateName}". Available: ${Object.keys(TEMPLATES).join(", ")}`
+    );
+  }
+  let text;
+  let name;
+  if (transcriptFile === "-") {
+    text = (await readStdinText()).trim();
+    if (!text) throw new InputError("No text received on stdin.");
+  } else {
+    if (!existsSync(transcriptFile)) {
+      throw new InputError(`File not found: ${transcriptFile}`);
+    }
+    text = readFileSync(transcriptFile, "utf-8").trim();
+    name = basename(transcriptFile, ".txt");
+  }
+  const output = templateFn(text, name);
+  if (opts.out) {
+    await writeFile(opts.out, output, "utf-8");
+    ctx2.note(`${pc2.green("\u2713")} Written to: ${opts.out}
+`);
+  }
+  if (opts.copy) {
+    const copied = await copyToClipboard(output);
+    if (copied) ctx2.note(pc2.gray("  Copied to clipboard.\n"));
+  }
+  ctx2.ok(
+    "prompt",
+    { template: templateName, output },
+    () => process.stdout.write(output)
+  );
+}
+
+// src/audio/auto-source.ts
+var MONITOR_RE = /\.monitor\b|\bmonitor\b/i;
+function pickAutoSource(sources) {
+  const physical = sources.filter(
+    (s) => s.id !== "default" && !MONITOR_RE.test(s.id) && !MONITOR_RE.test(s.label)
+  );
+  const preferred = physical.find((s) => /input/i.test(s.id));
+  return (preferred ?? physical[0])?.id ?? "default";
+}
+
+// src/audio/capture.ts
+var _factory = null;
+async function getAudioFactory() {
+  if (_factory) return _factory;
+  const platform = process.platform;
+  if (platform === "linux") {
+    const { LinuxPulseCaptureFactory } = await import('./linux-pulse-AROLYZNB.js');
+    _factory = new LinuxPulseCaptureFactory();
+  } else if (platform === "darwin") {
+    const { MacAvFoundationFactory } = await import('./mac-avfoundation-COPCFRZT.js');
+    _factory = new MacAvFoundationFactory();
+  } else if (platform === "win32") {
+    const { WindowsDshowFactory } = await import('./windows-dshow-O2GU4ZLR.js');
+    _factory = new WindowsDshowFactory();
+  } else {
+    throw new Error(
+      `Unsupported platform: ${platform}. Supported platforms: linux, darwin, win32.`
+    );
+  }
+  return _factory;
+}
+async function ensureUploadConsent(ctx2) {
+  const config = await loadConfig();
+  if (config.consent.uploadsAcknowledged) return;
+  if (ctx2.yes) {
+    config.consent.uploadsAcknowledged = true;
+    config.consent.acknowledgedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await saveConfig(config).catch(() => {
+    });
+    return;
+  }
+  if (!process.stdout.isTTY || ctx2.json) {
+    ctx2.note(
+      `${pc2.yellow("\u26A0  recmp3 will upload audio to the configured provider for transcription.\n")}   Pass --yes or set RECMP3_YES=1 to suppress this in scripts.
+`
+    );
+    return;
+  }
+  process.stdout.write(
+    `
+${pc2.bold("  recmp3 will upload your audio to the transcription provider.\n")}${pc2.gray("  Audio is transmitted over HTTPS. Provider data retention terms apply.\n")}${pc2.gray(`  Current provider: ${config.provider.default}
+`)}
+  Continue? [Y/n] `
+  );
+  const answer = await new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.once("line", (line) => {
+      rl.close();
+      resolve(line.trim().toLowerCase());
+    });
+    rl.once("close", () => resolve("y"));
+  });
+  if (answer === "n" || answer === "no") {
+    process.stdout.write(pc2.gray("  Cancelled. No audio was uploaded.\n\n"));
+    process.exit(0);
+  }
+  config.consent.uploadsAcknowledged = true;
+  config.consent.acknowledgedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveConfig(config).catch(() => {
+  });
+  process.stdout.write("\n");
+}
+function formatDate(d = /* @__PURE__ */ new Date()) {
+  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())}`;
+}
+function generateRecordingName(opts) {
+  const ext = opts.ext ?? "wav";
+  const ts = formatDate();
+  if (opts.name) {
+    const slug = opts.name.toLowerCase().replace(/[^a-z0-9-_]+/g, "-").replace(/^-+|-+$/g, "");
+    return `${slug}-${ts}.${ext}`;
+  }
+  const prefix = opts.prefix ?? "rec";
+  return `${prefix}-${ts}.${ext}`;
+}
+function transcriptPath(audioPath, ext) {
+  const base = audioPath.replace(/\.(wav|mp3|m4a|ogg|flac)$/i, "");
+  return `${base}.${ext}`;
+}
+function buildOutputPath(dir, name) {
+  return join(dir, name);
+}
+async function writeTranscriptFiles(audioPath, result) {
+  const txtPath = transcriptPath(audioPath, "txt");
+  const jsonPath = transcriptPath(audioPath, "json");
+  await writeFile(txtPath, `${result.text}
+`, "utf-8");
+  const meta = {
+    text: result.text,
+    provider: result.provider,
+    model: result.model,
+    language: result.language,
+    durationSec: result.durationSec,
+    latencyMs: result.latencyMs,
+    audioFile: audioPath,
+    segments: result.segments
+  };
+  await writeFile(jsonPath, `${JSON.stringify(meta, null, 2)}
+`, "utf-8");
+  return { txtPath, jsonPath };
+}
+var execFileAsync = promisify(execFile);
+async function transcribeWithChunking(provider, input, chunkSeconds = 600) {
+  const fileStat = await stat(input.audioPath);
+  if (fileStat.size <= provider.maxFileSizeBytes) {
+    return provider.transcribe(input);
+  }
+  const tmpDir = join(
+    (await import('os')).tmpdir(),
+    `recmp3-chunks-${Date.now()}`
+  );
+  await mkdir(tmpDir, { recursive: true });
+  const ffmpeg = await findFfmpeg();
+  const chunkPattern = join(tmpDir, "chunk-%04d.wav");
+  await execFileAsync(ffmpeg, [
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-i",
+    input.audioPath,
+    "-f",
+    "segment",
+    "-segment_time",
+    String(chunkSeconds),
+    "-c",
+    "copy",
+    chunkPattern
+  ]);
+  const files = (await readdir(tmpDir)).filter((f) => f.startsWith("chunk-") && f.endsWith(".wav")).sort().map((f) => join(tmpDir, f));
+  if (files.length === 0) {
+    return provider.transcribe(input);
+  }
+  const results = [];
+  for (const chunkPath of files) {
+    const result = await provider.transcribe({
+      ...input,
+      audioPath: chunkPath
+    });
+    results.push(result);
+  }
+  const combinedText = results.map((r) => r.text).join(" ");
+  const totalLatency = results.reduce((sum, r) => sum + r.latencyMs, 0);
+  return {
+    text: combinedText,
+    language: results[0]?.language,
+    durationSec: results.reduce((sum, r) => sum + (r.durationSec ?? 0), 0),
+    raw: results.map((r) => r.raw),
+    provider: results[0]?.provider ?? provider.name,
+    model: results[0]?.model ?? "",
+    latencyMs: totalLatency
+  };
+}
+var execFileAsync2 = promisify(execFile);
+async function concatSegments(segments, outputPath, tmpDir, format = "wav") {
+  const validSegments = segments.filter((s) => s.sizeBytes > 0);
+  if (validSegments.length === 0) {
+    throw new AudioCaptureError(
+      "No audio was recorded. The recording was empty or too short."
+    );
+  }
+  const ffmpeg = await findFfmpeg();
+  if (validSegments.length === 1) {
+    if (format === "wav") {
+      const { copyFile } = await import('fs/promises');
+      await copyFile(validSegments[0].path, outputPath);
+      return outputPath;
+    }
+    await execFileAsync2(ffmpeg, [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-i",
+      validSegments[0].path,
+      "-c:a",
+      "libmp3lame",
+      "-b:a",
+      "192k",
+      "-y",
+      outputPath
+    ]);
+    return outputPath;
+  }
+  const listPath = join(tmpDir, "concat-list.txt");
+  const listContent = validSegments.map((s) => `file '${s.path.replace(/'/g, "'\\''")}'`).join("\n");
+  await writeFile(listPath, listContent, "utf-8");
+  const codecArgs = format === "mp3" ? ["-c:a", "libmp3lame", "-b:a", "192k"] : ["-c", "copy"];
+  await execFileAsync2(ffmpeg, [
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-f",
+    "concat",
+    "-safe",
+    "0",
+    "-i",
+    listPath,
+    ...codecArgs,
+    "-y",
+    outputPath
+  ]);
+  return outputPath;
+}
+var RecorderUI = ({
+  capture,
+  captureOpts,
+  outputPath,
+  onResult
+}) => {
+  const { exit } = useApp();
+  const [status, setStatus] = useState("recording");
+  const [elapsedMs, setElapsedMs] = useState(0);
+  const [segmentCount, setSegmentCount] = useState(1);
+  const [statusMessage, setStatusMessage] = useState("");
+  const [busy, setBusy] = useState(false);
+  const segmentsRef = useRef([]);
+  const accumulatedMsRef = useRef(0);
+  const segmentStartRef = useRef(Date.now());
+  const currentSegmentIndexRef = useRef(1);
+  const isRecordingRef = useRef(true);
+  useEffect(() => {
+    const interval = setInterval(() => {
+      if (isRecordingRef.current) {
+        setElapsedMs(
+          accumulatedMsRef.current + (Date.now() - segmentStartRef.current)
+        );
+      }
+    }, 100);
+    return () => clearInterval(interval);
+  }, []);
+  const stopCurrentSegment = useCallback(async () => {
+    if (!isRecordingRef.current) return null;
+    try {
+      const segment = await capture.stop();
+      accumulatedMsRef.current += Date.now() - segmentStartRef.current;
+      isRecordingRef.current = false;
+      segmentsRef.current.push(segment);
+      return segment;
+    } catch {
+      return null;
+    }
+  }, [capture]);
+  const startNewSegment = useCallback(async () => {
+    currentSegmentIndexRef.current += 1;
+    const segPath = `${captureOpts.tmpDir}/segment-${String(currentSegmentIndexRef.current).padStart(4, "0")}.wav`;
+    await capture.start({ ...captureOpts, outputPath: segPath });
+    segmentStartRef.current = Date.now();
+    isRecordingRef.current = true;
+    setSegmentCount(currentSegmentIndexRef.current + 1);
+  }, [capture, captureOpts]);
+  const handlePause = useCallback(async () => {
+    if (busy || status !== "recording") return;
+    setBusy(true);
+    await stopCurrentSegment();
+    setStatus("paused");
+    setBusy(false);
+  }, [busy, status, stopCurrentSegment]);
+  const handleResume = useCallback(async () => {
+    if (busy || status !== "paused") return;
+    setBusy(true);
+    await startNewSegment();
+    setStatus("recording");
+    setBusy(false);
+  }, [busy, status, startNewSegment]);
+  const handleSave = useCallback(async () => {
+    if (busy || status !== "recording" && status !== "paused") return;
+    setBusy(true);
+    setStatus("saving");
+    try {
+      await stopCurrentSegment();
+      setStatusMessage("Concatenating segments...");
+      const finalPath = await concatSegments(
+        segmentsRef.current,
+        outputPath,
+        captureOpts.tmpDir,
+        "wav"
+      );
+      setStatusMessage("");
+      setStatus("done");
+      onResult({
+        cancelled: false,
+        outputPath: finalPath,
+        segments: segmentsRef.current,
+        totalDurationMs: accumulatedMsRef.current
+      });
+      setTimeout(() => exit(), 800);
+    } catch (err) {
+      setStatus("error");
+      setStatusMessage(err instanceof Error ? err.message : String(err));
+      setTimeout(() => exit(), 2e3);
+    }
+  }, [
+    busy,
+    status,
+    stopCurrentSegment,
+    outputPath,
+    captureOpts.tmpDir,
+    onResult,
+    exit
+  ]);
+  const handleCancel = useCallback(async () => {
+    if (busy) return;
+    setBusy(true);
+    await capture.dispose();
+    setStatus("cancelled");
+    onResult({ cancelled: true, segments: [], totalDurationMs: 0 });
+    setTimeout(() => exit(), 300);
+  }, [busy, capture, onResult, exit]);
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      handleCancel();
+      return;
+    }
+    if (input === "c" || key.escape) {
+      handleCancel();
+      return;
+    }
+    if (input === "p" || input === " ") {
+      if (status === "recording") handlePause();
+      else if (status === "paused") handleResume();
+      return;
+    }
+    if (input === "s" || key.return) {
+      handleSave();
+      return;
+    }
+  });
+  const elapsed = Math.floor(elapsedMs / 1e3);
+  const h = Math.floor(elapsed / 3600);
+  const m = Math.floor(elapsed % 3600 / 60);
+  const s = elapsed % 60;
+  const timeStr = `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+  const statusColors = {
+    recording: "red",
+    paused: "yellow",
+    saving: "cyan",
+    done: "green",
+    cancelled: "gray",
+    error: "red"
+  };
+  const statusLabels = {
+    recording: "\u25CF REC",
+    paused: "\u2016 PAUSED",
+    saving: "\u25CC SAVING",
+    done: "\u2713 DONE",
+    cancelled: "\u2717 CANCELLED",
+    error: "\u2717 ERROR"
+  };
+  const showControls = status === "recording" || status === "paused";
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      paddingX: 2,
+      paddingY: 1,
+      width: 44,
+      children: [
+        /* @__PURE__ */ jsx(Box, { justifyContent: "center", children: /* @__PURE__ */ jsxs(
+          Text,
+          {
+            bold: true,
+            color: statusColors[status],
+            children: [
+              statusLabels[status],
+              " ",
+              timeStr
+            ]
+          }
+        ) }),
+        statusMessage ? /* @__PURE__ */ jsx(Box, { justifyContent: "center", marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "cyan", children: statusMessage }) }) : showControls ? /* @__PURE__ */ jsx(Box, { justifyContent: "center", marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          status === "recording" ? "[p] pause" : "[p] resume",
+          " [s] save [c] cancel"
+        ] }) }) : null
+      ]
+    }
+  );
+};
+async function runRecorderTUI(capture, captureOpts, outputPath) {
+  return new Promise((resolve) => {
+    let result = null;
+    const { waitUntilExit } = render(
+      /* @__PURE__ */ jsx(
+        RecorderUI,
+        {
+          capture,
+          captureOpts: {
+            ...captureOpts,
+            outputPath: `${captureOpts.tmpDir}/segment-0001.wav`
+          },
+          outputPath,
+          onResult: (r) => {
+            result = r;
+          }
+        }
+      ),
+      { exitOnCtrlC: false }
+    );
+    waitUntilExit().then(() => {
+      resolve(result ?? { cancelled: true, segments: [], totalDurationMs: 0 });
+    });
+  });
+}
+
+// src/commands/record.ts
+async function resolveSource(opts, config, factory) {
+  const requested = opts.source ?? config.audio.source;
+  if (requested !== "auto") return requested;
+  const sources = await factory.listSources();
+  return pickAutoSource(sources);
+}
+async function runRecord(opts, ctx2) {
+  const config = await loadConfig();
+  const durationSec = opts.duration ? Number(opts.duration) : void 0;
+  const headless = opts.tui === false || durationSec !== void 0 || ctx2.json || process.stdout.isTTY !== true;
+  const outDir = opts.out ?? config.output.recordingDir;
+  await mkdir(outDir, { recursive: true });
+  if (headless) {
+    await recordHeadless(opts, ctx2, config, outDir, durationSec);
+  } else {
+    await recordTui(opts, ctx2, config, outDir);
+  }
+}
+async function recordHeadless(opts, ctx2, config, outDir, durationSec) {
+  if (opts.mp3)
+    ctx2.note(pc2.yellow("  --mp3 is ignored in headless mode; saving WAV.\n"));
+  const filename = generateRecordingName({
+    name: opts.name,
+    prefix: config.output.namePrefix,
+    ext: "wav"
+  });
+  const outputPath = buildOutputPath(outDir, filename);
+  const factory = await getAudioFactory();
+  const capture = factory.create();
+  const source = await resolveSource(opts, config, factory);
+  try {
+    await capture.start({
+      source,
+      outputPath,
+      sampleRate: 16e3,
+      channels: 1,
+      format: "wav"
+    });
+  } catch (err) {
+    if (err instanceof RecmpError) throw err;
+    throw new RecmpError(
+      "AUDIO_START_FAILED",
+      `Failed to start recording: ${err instanceof Error ? err.message : String(err)}`,
+      3
+    );
+  }
+  ctx2.note(
+    pc2.cyan(
+      durationSec !== void 0 ? `  Recording for ${durationSec}s...
+` : "  Recording... press Ctrl+C to stop.\n"
+    )
+  );
+  await new Promise((resolve) => {
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      process.off("SIGINT", finish);
+      if (timer) clearTimeout(timer);
+      resolve();
+    };
+    const timer = durationSec !== void 0 ? setTimeout(finish, durationSec * 1e3) : null;
+    process.on("SIGINT", finish);
+  });
+  const segment = await capture.stop();
+  await capture.dispose().catch(() => {
+  });
+  ctx2.note(`${pc2.green("\u2713")} Saved: ${segment.path}
+`);
+  const transcription = opts.transcribe ? await transcribeRecording(segment.path, opts, ctx2, config) : void 0;
+  ctx2.ok(
+    "record",
+    {
+      audioPath: segment.path,
+      durationSec: segment.durationSec,
+      sizeBytes: segment.sizeBytes,
+      transcription
+    },
+    () => {
+      if (transcription) process.stdout.write(`${transcription.text}
+`);
+    }
+  );
+}
+async function recordTui(opts, ctx2, config, outDir) {
+  const ext = opts.mp3 ? "mp3" : "wav";
+  const filename = generateRecordingName({
+    name: opts.name,
+    prefix: config.output.namePrefix,
+    ext
+  });
+  const outputPath = buildOutputPath(outDir, filename);
+  const sessionId = randomBytes(4).toString("hex");
+  const tmpDir = join(tmpdir(), `recmp3-${sessionId}`);
+  await mkdir(tmpDir, { recursive: true });
+  const factory = await getAudioFactory();
+  const capture = factory.create();
+  const source = await resolveSource(opts, config, factory);
+  const firstSegPath = join(tmpDir, "segment-0001.wav");
+  try {
+    await capture.start({
+      source,
+      outputPath: firstSegPath,
+      sampleRate: 16e3,
+      channels: 1,
+      format: "wav"
+    });
+  } catch (err) {
+    await rm(tmpDir, { recursive: true, force: true });
+    if (err instanceof RecmpError) throw err;
+    throw new RecmpError(
+      "AUDIO_START_FAILED",
+      `Failed to start recording: ${err instanceof Error ? err.message : String(err)}`,
+      3
+    );
+  }
+  let result;
+  try {
+    result = await runRecorderTUI(
+      capture,
+      { source, sampleRate: 16e3, channels: 1, format: "wav", tmpDir },
+      outputPath
+    );
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+  if (result.cancelled || !result.outputPath) {
+    ctx2.note(pc2.gray("  Recording cancelled.\n"));
+    return;
+  }
+  process.stdout.write(`
+${pc2.green("\u2713")} Saved: ${result.outputPath}
+`);
+  if (opts.transcribe) {
+    const transcription = await transcribeRecording(
+      result.outputPath,
+      opts,
+      ctx2,
+      config
+    );
+    const shouldPrint = opts.print !== false && config.ui.printOnTranscribe;
+    if (shouldPrint) process.stdout.write(`
+${transcription.text}
+
+`);
+  }
+}
+async function transcribeRecording(audioPath, opts, ctx2, config) {
+  const providerConfig = { ...config };
+  if (opts.provider) {
+    providerConfig.provider.default = opts.provider;
+  }
+  if (providerUploads(providerConfig.provider.default)) {
+    await ensureUploadConsent(ctx2);
+  }
+  ctx2.note(pc2.cyan("  Transcribing...\n"));
+  const provider = await createProvider(providerConfig);
+  const transcription = await transcribeWithChunking(
+    provider,
+    {
+      audioPath,
+      language: opts.lang ?? config.transcription.defaultLanguage,
+      responseFormat: "verbose_json"
+    },
+    config.transcription.chunking.chunkSeconds
+  );
+  let transcriptPath2;
+  if (config.output.saveTranscriptToFile) {
+    const { txtPath } = await writeTranscriptFiles(audioPath, transcription);
+    transcriptPath2 = txtPath;
+    ctx2.note(`${pc2.green("\u2713")} Transcript: ${txtPath}
+`);
+  }
+  const shouldCopy = opts.copy !== false && config.ui.clipboardOnTranscribe;
+  if (shouldCopy) {
+    const copied = await copyToClipboard(transcription.text);
+    if (copied) ctx2.note(pc2.gray("  Copied to clipboard.\n"));
+  }
+  ctx2.note(
+    pc2.gray(
+      `  Provider: ${transcription.provider} \xB7 Model: ${transcription.model} \xB7 ${(transcription.latencyMs / 1e3).toFixed(1)}s
+`
+    )
+  );
+  return {
+    text: transcription.text,
+    provider: transcription.provider,
+    model: transcription.model,
+    language: transcription.language,
+    durationSec: transcription.durationSec,
+    latencyMs: transcription.latencyMs,
+    segments: transcription.segments,
+    transcriptPath: transcriptPath2
+  };
+}
+async function runSources(ctx2) {
+  let sources = [];
+  try {
+    const factory = await getAudioFactory();
+    sources = await factory.listSources();
+  } catch (err) {
+    throw err instanceof RecmpError ? err : new RecmpError(
+      "AUDIO_CAPTURE_ERROR",
+      `Failed to list audio sources: ${err instanceof Error ? err.message : String(err)}. Make sure ffmpeg is installed.`,
+      3
+    );
+  }
+  const platform = process.platform;
+  const recommended = sources.length ? pickAutoSource(sources) : "default";
+  ctx2.ok("sources", { platform, sources, recommended }, () => {
+    const platformLabels = {
+      linux: "Linux (PulseAudio/PipeWire)",
+      darwin: "macOS (AVFoundation)",
+      win32: "Windows (DirectShow)"
+    };
+    const platformLabel = platformLabels[platform] ?? platform;
+    console.log(`
+${pc2.bold("Audio sources")} on ${platformLabel}:
+`);
+    if (sources.length === 0) {
+      console.log(
+        pc2.yellow("  No audio sources found. Check your audio hardware.")
+      );
+      return;
+    }
+    for (const source of sources) {
+      const markers = [
+        source.isDefault ? pc2.green(" (default)") : "",
+        source.id === recommended ? pc2.yellow(" (recommended)") : ""
+      ].join("");
+      const id = pc2.cyan(source.id);
+      const label = source.label !== source.id ? pc2.gray(` \u2014 ${source.label}`) : "";
+      console.log(`  ${id}${label}${markers}`);
+    }
+    console.log(
+      `
+${pc2.gray("  Best mic:")} ${pc2.cyan("recmp3 record --source auto")}`
+    );
+    console.log(`${pc2.gray("  Specific:")} recmp3 record --source <id>`);
+    console.log(
+      pc2.gray("  Or set:   RECMP3_SOURCE=<id> in your environment\n")
+    );
+  });
+}
+async function runTranscribe(audioFile, opts, ctx2) {
+  let path = audioFile;
+  let tmpFromStdin = null;
+  if (audioFile === "-") {
+    const buf = await readStdinBuffer();
+    if (buf.length === 0) throw new InputError("No audio received on stdin.");
+    const dir = await mkdtemp(join(tmpdir(), "recmp3-stdin-"));
+    tmpFromStdin = join(dir, "input.wav");
+    await writeFile(tmpFromStdin, buf);
+    path = tmpFromStdin;
+  } else if (!existsSync(audioFile)) {
+    throw new InputError(`File not found: ${audioFile}`);
+  }
+  try {
+    const config = await loadConfig();
+    if (opts.provider) {
+      config.provider.default = opts.provider;
+    }
+    if (providerUploads(config.provider.default)) {
+      await ensureUploadConsent(ctx2);
+    }
+    const provider = await createProvider(config);
+    ctx2.note(pc2.cyan(`  Transcribing with ${provider.name}...
+`));
+    const result = await transcribeWithChunking(
+      provider,
+      {
+        audioPath: path,
+        language: opts.lang ?? config.transcription.defaultLanguage,
+        responseFormat: "verbose_json"
+      },
+      config.transcription.chunking.chunkSeconds
+    );
+    let transcriptPath2;
+    if (config.output.saveTranscriptToFile && !tmpFromStdin) {
+      const { txtPath } = await writeTranscriptFiles(audioFile, result);
+      transcriptPath2 = txtPath;
+      ctx2.note(`${pc2.green("\u2713")} Transcript saved: ${txtPath}
+`);
+    }
+    if (opts.copy) {
+      const copied = await copyToClipboard(result.text);
+      if (copied) ctx2.note(pc2.gray("  Copied to clipboard.\n"));
+    }
+    ctx2.note(
+      pc2.gray(
+        `  ${provider.name} \xB7 ${result.model} \xB7 ${(result.latencyMs / 1e3).toFixed(1)}s
+`
+      )
+    );
+    ctx2.ok(
+      "transcribe",
+      {
+        text: result.text,
+        provider: result.provider,
+        model: result.model,
+        language: result.language,
+        durationSec: result.durationSec,
+        latencyMs: result.latencyMs,
+        segments: result.segments,
+        transcriptPath: transcriptPath2
+      },
+      // Human mode: transcript text on stdout (pipeable), nothing else.
+      () => process.stdout.write(`${result.text}
+`)
+    );
+  } finally {
+    if (tmpFromStdin) {
+      await rm(join(tmpFromStdin, ".."), {
+        recursive: true,
+        force: true
+      }).catch(() => {
+      });
+    }
+  }
+}
+
+// src/agent/mcp.ts
+async function callCommand(run, args) {
+  const ctx2 = AgentContext.forCapture();
+  const sink = ctx2.sink;
+  try {
+    await run(args, ctx2);
+  } catch (err) {
+    ctx2.fail(err, "mcp");
+  }
+  const envelope = sink.envelope;
+  return {
+    isError: envelope?.ok === false,
+    content: [
+      { type: "text", text: JSON.stringify(envelope, null, 2) }
+    ]
+  };
+}
+function descriptionFor(tool) {
+  return MANIFEST.commands.find((c) => c.tool === tool)?.summary ?? "";
+}
+function register(server, tool, inputSchema, run) {
+  server.registerTool(
+    tool,
+    { description: descriptionFor(tool), inputSchema },
+    async (args) => callCommand(run, args ?? {})
+  );
+}
+async function runMcpServer() {
+  const server = new McpServer({
+    name: MANIFEST.name,
+    version: MANIFEST.version
+  });
+  register(
+    server,
+    "recmp3_transcribe",
+    {
+      file: z.string().describe("Audio file path (must exist on the server host)"),
+      provider: z.string().optional(),
+      lang: z.string().optional()
+    },
+    (a, ctx2) => runTranscribe(
+      a.file,
+      { provider: a.provider, lang: a.lang },
+      ctx2
+    )
+  );
+  register(
+    server,
+    "recmp3_prompt",
+    {
+      file: z.string().describe('Transcript file path, or "-" for stdin'),
+      template: z.string().optional()
+    },
+    (a, ctx2) => runPrompt(a.file, { template: a.template }, ctx2)
+  );
+  register(server, "recmp3_sources", {}, (_a, ctx2) => runSources(ctx2));
+  register(server, "recmp3_doctor", {}, (_a, ctx2) => runDoctor(ctx2));
+  register(server, "recmp3_config_show", {}, (_a, ctx2) => runConfigShow(ctx2));
+  register(server, "recmp3_manifest", {}, (_a, ctx2) => runManifest(ctx2));
+  register(
+    server,
+    "recmp3_record",
+    {
+      duration: z.number().describe("Seconds to record (headless)"),
+      name: z.string().optional(),
+      out: z.string().optional(),
+      transcribe: z.boolean().optional(),
+      provider: z.string().optional(),
+      lang: z.string().optional(),
+      source: z.string().optional().describe('Audio source id, or "auto" for the best physical mic')
+    },
+    (a, ctx2) => runRecord(
+      {
+        duration: String(a.duration),
+        name: a.name,
+        out: a.out,
+        transcribe: a.transcribe,
+        provider: a.provider,
+        lang: a.lang,
+        source: a.source
+      },
+      ctx2
+    )
+  );
+  let closing = false;
+  const shutdown = async () => {
+    if (closing) return;
+    closing = true;
+    try {
+      await server.close();
+    } catch {
+    }
+    process.exit(0);
+  };
+  process.once("SIGTERM", shutdown);
+  process.once("SIGINT", shutdown);
+  process.stdin.once("end", shutdown);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+var program = new Command();
+var ctx = new AgentContext();
+program.name("recmp3").description(
+  "Record audio, transcribe with AI, output developer-ready prompts."
+).version(VERSION, "-v, --version").option(
+  "--json",
+  "Emit a stable machine-readable JSON envelope on stdout",
+  false
+).option("-y, --yes", "Skip all interactive prompts (consent, setup)", false).option("--quiet", "Suppress progress/diagnostic output on stderr", false).option("--no-color", "Disable colored output").option("--debug", "Enable debug output", false).option("--verbose", "Enable verbose output", false).hook("preAction", (_thisCommand, actionCommand) => {
+  const opts = actionCommand.optsWithGlobals();
+  initLogger({ debug: opts.debug, verbose: opts.verbose });
+  ctx = AgentContext.fromGlobals(opts);
+});
+program.action(async () => {
+  await handleError("record", () => runRecord({}, ctx));
+});
+program.command("record").description("Record audio from your microphone").option("-n, --name <name>", 'Output filename stem (e.g. "my-idea")').option("-o, --out <dir>", "Output directory").option("-t, --transcribe", "Transcribe immediately after recording").option("--mp3", "Save as MP3 instead of WAV (post-processing)").option(
+  "--provider <name>",
+  "Override transcription provider (groq, openai, local-whisper)"
+).option("--lang <code>", "Force language code (e.g. es, en)").option(
+  "--source <id>",
+  'Audio source id, or "auto" to pick the best physical mic'
+).option(
+  "--duration <seconds>",
+  "Headless: record for N seconds then stop (no TUI)"
+).option(
+  "--no-tui",
+  "Force headless capture (record until SIGINT or --duration)"
+).option(
+  "--copy",
+  "Copy transcript to clipboard (default: on with --transcribe)"
+).option("--no-copy", "Do not copy transcript to clipboard").option(
+  "--print",
+  "Print transcript to stdout (default: on with --transcribe)"
+).option("--no-print", "Do not print transcript to stdout").action(async (opts) => {
+  await handleError("record", () => runRecord(opts, ctx));
+});
+program.command("transcribe <file>").description('Transcribe an existing audio file ("-" reads audio from stdin)').option(
+  "--provider <name>",
+  "Override provider (groq, openai, local-whisper)"
+).option("--lang <code>", "Force language code").option("--copy", "Copy transcript to clipboard").action(async (file, opts) => {
+  await handleError("transcribe", () => runTranscribe(file, opts, ctx));
+});
+program.command("sources").description("List available audio input sources for your OS").action(async () => {
+  await handleError("sources", () => runSources(ctx));
+});
+var configCmd = program.command("config").description("Manage recmp3 configuration");
+configCmd.command("init").description(
+  "First-time setup (interactive, or flag-driven when non-interactive)"
+).option("--provider <name>", "Provider (groq, openai, local-whisper)").option("--lang <code>", "Default language code").option("--outdir <dir>", "Recordings output directory").option("--key <value>", "API key to store in the OS keychain").action(async (opts) => {
+  await handleError("config init", () => runConfigInit(opts, ctx));
+});
+configCmd.command("show").description("Show resolved configuration (API keys redacted)").action(async () => {
+  await handleError("config show", () => runConfigShow(ctx));
+});
+configCmd.command("path").description("Print path to config file").action(async () => {
+  await handleError("config path", () => runConfigPath(ctx));
+});
+configCmd.command("set <key> <value>").description("Set a config value (e.g. provider.default groq)").action(async (key, value) => {
+  await handleError("config set", () => runConfigSet(key, value, ctx));
+});
+configCmd.command("set-key <provider>").description(
+  "Store an API key in the OS keychain (value from --key, stdin, or env)"
+).option(
+  "--key <value>",
+  "API key value (otherwise read from stdin or *_API_KEY env)"
+).action(async (provider, opts) => {
+  await handleError(
+    "config set-key",
+    () => runConfigSetKey(provider, opts, ctx)
+  );
+});
+program.command("doctor").description("Run preflight checks to verify your setup").action(async () => {
+  await handleError("doctor", () => runDoctor(ctx));
+});
+program.command("prompt <file>").description(
+  'Wrap a transcript file in a prompt template ("-" reads from stdin)'
+).option(
+  "-t, --template <name>",
+  "Template name (claude-code, prd, bug, todo, meeting-notes, commit-message, raw)",
+  "claude-code"
+).option("--copy", "Copy output to clipboard").option("--out <file>", "Write output to a file").option("--list-templates", "List available templates").action(async (file, opts) => {
+  if (opts.listTemplates) {
+    listTemplates();
+    return;
+  }
+  await handleError("prompt", () => runPrompt(file, opts, ctx));
+});
+program.command("manifest").description("Print the command/tool manifest (use --json for machine form)").action(async () => {
+  await handleError("manifest", () => runManifest(ctx));
+});
+program.command("mcp").description("Start the Model Context Protocol server over stdio").action(async () => {
+  await runMcpServer();
+});
+async function handleError(command, fn) {
+  try {
+    await fn();
+  } catch (err) {
+    const payload = toErrorPayload(err);
+    ctx.fail(err, command);
+    if (process.env.RECMP3_DEBUG && err instanceof Error) {
+      process.stderr.write(`${err.stack ?? ""}
+`);
+    }
+    process.exit(payload.exitCode);
+  }
+}
+program.parseAsync(process.argv).catch((err) => {
+  const payload = toErrorPayload(err);
+  process.stderr.write(`${pc2.red("\u2717")} ${payload.message}
+`);
+  process.exit(err instanceof RecmpError ? err.exitCode : ExitCode.UNKNOWN);
+});