voxflow 1.15.0 → 1.15.2

package/lib/commands/podcast/generate.js

@@ -0,0 +1,127 @@
+/**
+ * Podcast command — LLM dialogue generation (legacy + ai-sdk engines).
+ */
+
+'use strict';
+
+const { PODCAST_DEFAULTS } = require('../../core/config');
+const { request, throwApiError, throwNetworkError } = require('../../core/http');
+const { startSpinner } = require('../../core/spinner');
+const { parseDialogueText, parseStructuredScript } = require('./dialogue');
+
+/**
+ * Determine which engine to use.
+ */
+function resolveEngine(engine) {
+  if (engine === 'legacy') {
+    console.warn('\x1b[33m⚠ Warning: the legacy podcast engine is deprecated and will be removed in a future release.\x1b[0m');
+    console.warn('\x1b[33m  Use --engine ai-sdk (default) for better quality and more features.\x1b[0m\n');
+    return 'legacy';
+  }
+  if (engine === 'ai-sdk') return 'ai-sdk';
+  return 'ai-sdk';
+}
+
+/**
+ * Generate dialogue via the legacy engine.
+ */
+async function generateDialogueLegacy(apiBase, token, opts) {
+  const spinner = startSpinner('\n[1/3] Generating dialogue text (legacy)...');
+
+  let status, data;
+  try {
+    ({ status, data } = await request(`${apiBase}/api/llm/generate-dialogue`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`,
+      },
+      timeoutMs: 180_000,
+    }, {
+      prompt: opts.topic,
+      style: opts.style || opts.template,
+      length: opts.length,
+      dialogueMode: true,
+      autoSpeakerNames: true,
+      exchanges: opts.exchanges,
+    }));
+  } catch (err) {
+    spinner.stop('FAIL');
+    throwNetworkError(err, apiBase);
+  }
+
+  if (status !== 200 || data.code !== 'success') {
+    spinner.stop('FAIL');
+    throwApiError(status, data, 'Dialogue generation');
+  }
+
+  const text = data.text;
+  const voiceMapping = data.voiceMapping || {};
+  const quota = data.quota;
+  spinner.stop('OK');
+
+  const segments = parseDialogueText(text);
+  const speakers = [...new Set(segments.map(s => s.speaker))];
+
+  console.log(`    ${text.length} 字, ${segments.length} 段, ${speakers.length} 位说话者`);
+  console.log(`    说话者: ${speakers.join(', ')}`);
+  console.log(`    配额剩余: ${quota?.remaining ?? '?'}`);
+
+  return { text, segments, voiceMapping, speakers, quota, script: null };
+}
+
+/**
+ * Generate dialogue via the ai-sdk engine.
+ */
+async function generateDialogueAiSdk(apiBase, token, opts) {
+  const spinner = startSpinner('\n[1/3] Generating dialogue text (ai-sdk)...');
+
+  const durationMap = { short: '1-3', medium: '3-5', long: '5-10' };
+
+  let status, data;
+  try {
+    ({ status, data } = await request(`${apiBase}/api/podcast/generate-script`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`,
+      },
+      timeoutMs: 180_000,
+    }, {
+      topic: opts.topic,
+      speakerCount: opts.speakers || PODCAST_DEFAULTS.speakers,
+      colloquialLevel: opts.colloquial || 'medium',
+      language: opts.language || 'zh-CN',
+      duration: durationMap[opts.length] || '3-5',
+      autoMatchVoices: true
+    }));
+  } catch (err) {
+    spinner.stop('FAIL');
+    throwNetworkError(err, apiBase);
+  }
+
+  if (status !== 200 || data.code !== 'success') {
+    spinner.stop('FAIL');
+    throwApiError(status, data, 'Podcast script generation');
+  }
+
+  const podcastScript = data.script;
+  const voiceMapping = data.voiceMapping || {};
+  const quota = data.quota;
+  spinner.stop('OK');
+
+  const segments = parseStructuredScript(podcastScript);
+  const speakers = [...new Set(segments.map(s => s.speaker))];
+  const text = segments.map(s => `${s.speaker}: ${s.text}`).join('\n');
+
+  console.log(`    ${text.length} chars, ${segments.length} segments, ${speakers.length} speakers`);
+  console.log(`    Speakers: ${speakers.join(', ')}`);
+  if (podcastScript?.quality_score?.overall) {
+    console.log(`    Quality score: ${podcastScript.quality_score.overall}/10`);
+  }
+  console.log(`    Quota remaining: ${quota?.remaining ?? '?'}`);
+
+  return { text, segments, voiceMapping, speakers, quota, script: podcastScript };
+}
+
+module.exports = { resolveEngine, generateDialogueLegacy, generateDialogueAiSdk };

package/lib/commands/podcast/index.js

@@ -0,0 +1,561 @@
+/**
+ * VoxFlow CLI — Podcast command
+ *
+ * Thin orchestrator: delegates to submodules for dialogue generation,
+ * multi-voice TTS synthesis, and audio assembly.
+ *
+ * Submodules:
+ *   ./dialogue.js   — script loading, text parsing
+ *   ./generate.js   — LLM engines (legacy, ai-sdk)
+ *   ./synthesize.js — multi-voice TTS + assembly
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { PODCAST_DEFAULTS } = require('../../core/config');
+const { ApiError } = require('../../core/http');
+const { buildWav } = require('../../core/audio');
+const { computeGapsMs, VALID_PACE } = require('../../core/podcast-pacing');
+const { loadScript, parseStructuredScript } = require('./dialogue');
+const { resolveEngine, generateDialogueLegacy, generateDialogueAiSdk } = require('./generate');
+const { synthesizeAll } = require('./synthesize');
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+async function podcast(opts) {
+  const sigintHandler = () => {
+    console.log('\n\nGeneration cancelled.');
+    process.exit(130);
+  };
+  process.on('SIGINT', sigintHandler);
+
+  try {
+    return await _podcast(opts);
+  } finally {
+    process.removeListener('SIGINT', sigintHandler);
+  }
+}
+
+async function _podcast(opts) {
+  const style = opts.style || opts.template || PODCAST_DEFAULTS.template;
+  const length = opts.length || PODCAST_DEFAULTS.length;
+  const exchanges = opts.exchanges || PODCAST_DEFAULTS.exchanges;
+  const speed = opts.speed ?? PODCAST_DEFAULTS.speed;
+  const silence = opts.silence ?? PODCAST_DEFAULTS.silence;
+  const pace = opts.pace || 'natural';
+  const silenceExplicit = opts.silence != null;
+  const api = opts.api;
+  const token = opts.token;
+  const engine = resolveEngine(opts.engine || 'auto');
+  const colloquial = opts.colloquial || 'medium';
+  const speakers = opts.speakers || PODCAST_DEFAULTS.speakers;
+  const language = opts.language || 'zh-CN';
+  const formatJson = opts.format === 'json';
+  const noTts = opts.noTts || false;
+  const voiceOverride = opts.voice || null;
+  const scriptPath = opts.script || null;
+
+  const topic = opts.topic || 'Latest trends in technology';
+
+  // ── Input mode: read from .podcast.json ──
+  if (opts.input) {
+    return _podcastFromFile(opts);
+  }
+
+  // Default output path
+  let outputPath = opts.output;
+  if (!outputPath) {
+    const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const ext = noTts ? '.txt' : '.wav';
+    outputPath = path.resolve(`podcast-${ts}${ext}`);
+  }
+
+  console.log('\n=== VoxFlow Podcast Generator ===');
+  console.log(`Topic:      ${topic}`);
+  if (scriptPath) {
+    console.log(`Script:     ${scriptPath}`);
+  } else {
+    console.log(`Engine:     ${engine}`);
+    console.log(`Template:   ${style}`);
+    console.log(`Length:     ${length}`);
+    console.log(`Colloquial: ${colloquial}`);
+    console.log(`Speakers:   ${speakers}`);
+    console.log(`Language:   ${language}`);
+  }
+  console.log(`Speed:      ${speed}`);
+  if (voiceOverride) console.log(`Voice:      ${voiceOverride}`);
+  if (opts.bgm) console.log(`BGM:        ${opts.bgm} (ducking: ${opts.ducking ?? PODCAST_DEFAULTS.ducking})`);
+  console.log(`API:        ${api}`);
+  if (!noTts) console.log(`Output:     ${outputPath}`);
+
+  // Step 1: Get dialogue
+  let text, segments, voiceMapping, detectedSpeakers, podcastScript;
+
+  if (scriptPath) {
+    console.log('\n[1/3] 加载脚本文件...');
+    const script = loadScript(scriptPath);
+    segments = script.segments;
+    voiceMapping = script.voiceMapping;
+    detectedSpeakers = [...new Set(segments.map(s => s.speaker))];
+    text = segments.map(s => `${s.speaker}：${s.text}`).join('\n');
+    podcastScript = null;
+
+    console.log(`    ${text.length} chars, ${segments.length} segments, ${detectedSpeakers.length} speakers`);
+    console.log(`    Speakers: ${detectedSpeakers.join(', ')}`);
+  } else if (engine === 'ai-sdk') {
+    const result = await generateDialogueAiSdk(api, token, {
+      topic, style, length, exchanges, colloquial, speakers, language
+    });
+    text = result.text;
+    segments = result.segments;
+    voiceMapping = result.voiceMapping;
+    detectedSpeakers = result.speakers;
+    podcastScript = result.script;
+  } else {
+    const result = await generateDialogueLegacy(api, token, {
+      topic, style, length, exchanges, template: style
+    });
+    text = result.text;
+    segments = result.segments;
+    voiceMapping = result.voiceMapping;
+    detectedSpeakers = result.speakers;
+    podcastScript = result.script;
+  }
+
+  if (segments.length === 0) {
+    throw new Error('No dialogue segments found in generated text');
+  }
+
+  // Output .podcast.json if requested
+  if (formatJson) {
+    const jsonPath = outputPath.replace(/\.\w+$/, '.podcast.json');
+    const jsonContent = {
+      version: 1,
+      engine,
+      topic,
+      script: podcastScript || { dialogue: segments.map(s => ({ speaker: s.speaker, text: s.text, intent: s.intent || null, pauseAfterMs: s.pauseAfterMs ?? null })) },
+      voiceMapping,
+      meta: { colloquial, speakers, language, length, style }
+    };
+    const outDir = path.dirname(jsonPath);
+    fs.mkdirSync(outDir, { recursive: true });
+    fs.writeFileSync(jsonPath, JSON.stringify(jsonContent, null, 2), 'utf8');
+    console.log(`\n    JSON exported: ${jsonPath}`);
+  }
+
+  // --no-tts: script only
+  if (noTts) {
+    const textPath = outputPath.endsWith('.txt') ? outputPath : outputPath.replace(/\.\w+$/, '.txt');
+    const textContent = segments.map((s, i) => `[${i + 1}] ${s.speaker}：${s.text}`).join('\n\n');
+    const outDir = path.dirname(textPath);
+    fs.mkdirSync(outDir, { recursive: true });
+    fs.writeFileSync(textPath, textContent, 'utf8');
+
+    console.log(`\n=== Done (script only) ===`);
+    console.log(`Script: ${textPath}`);
+    return { outputPath: textPath, textPath, duration: 0, quotaUsed: 1 };
+  }
+
+  // Show voice assignments
+  console.log('\n    Voice assignments:');
+  for (const speaker of detectedSpeakers) {
+    if (voiceOverride) {
+      console.log(`      ${speaker} → ${voiceOverride} (override)`);
+    } else {
+      const mapping = voiceMapping[speaker];
+      if (mapping) {
+        console.log(`      ${speaker} → ${mapping.voiceId}`);
+      } else {
+        console.log(`      ${speaker} → (default)`);
+      }
+    }
+  }
+
+  // Step 2: Multi-voice TTS — within-turn pause markers split + splice (pace-aware)
+  const { pcmBuffers, quota: lastQuota, ttsCallCount } = await synthesizeAll(
+    api, token, segments, voiceMapping, speed, voiceOverride, { pace }
+  );
+
+  // Step 3: Build WAV — per-segment intent-driven gaps, applied with pace preset.
+  // --silence flag (when explicitly set) overrides intent gaps with a uniform value.
+  const stepLabel = opts.bgm ? '[3/4]' : '[3/3]';
+  console.log(`\n${stepLabel} 拼接音频...`);
+  const gapsMs = silenceExplicit
+    ? null
+    : computeGapsMs(segments, { pace });
+  const { wav, duration } = buildWav(pcmBuffers, gapsMs ? { gapsMs, fadeIn: true } : silence);
+
+  const outDir = path.dirname(outputPath);
+  fs.mkdirSync(outDir, { recursive: true });
+
+  const outputExt = path.extname(outputPath).toLowerCase();
+  const needsConvert = outputExt !== '.wav';
+  const wavWorkPath = needsConvert
+    ? outputPath.slice(0, -outputExt.length) + '.tmp.wav'
+    : outputPath;
+
+  fs.writeFileSync(wavWorkPath, wav);
+
+  const textPath = outputPath.slice(0, -outputExt.length) + '.txt';
+  const textContent = segments.map((s, i) => `[${i + 1}] ${s.speaker}：${s.text}`).join('\n\n');
+  fs.writeFileSync(textPath, textContent, 'utf8');
+
+  // Step 4 (optional): Mix BGM
+  if (opts.bgm) {
+    const { checkFfmpeg, mixWithBgm } = require('../../core/ffmpeg');
+    const ffmpegInfo = await checkFfmpeg();
+    if (!ffmpegInfo.available) {
+      throw new Error(
+        'ffmpeg is required for BGM mixing. Install it:\n' +
+        '  macOS: brew install ffmpeg\n' +
+        '  Ubuntu: sudo apt install ffmpeg\n' +
+        '  Windows: https://ffmpeg.org/download.html'
+      );
+    }
+
+    console.log(`\n[4/4] 混合背景音乐 (ducking: ${opts.ducking ?? PODCAST_DEFAULTS.ducking})...`);
+    const mixedPath = wavWorkPath.replace('.tmp.wav', '-mixed.tmp.wav').replace(/(?<!\.tmp)\.wav$/, '-mixed.wav');
+    await mixWithBgm(wavWorkPath, opts.bgm, mixedPath, {
+      ducking: opts.ducking ?? PODCAST_DEFAULTS.ducking,
+    });
+
+    fs.copyFileSync(mixedPath, wavWorkPath);
+    try { fs.unlinkSync(mixedPath); } catch { /* ignore */ }
+  }
+
+  // Convert to target format if needed
+  if (needsConvert) {
+    const { checkFfmpeg, convertAudioFormat } = require('../../core/ffmpeg');
+    const ffmpegInfo = await checkFfmpeg();
+    if (!ffmpegInfo.available) {
+      fs.renameSync(wavWorkPath, outputPath);
+      console.log(`\n    Warning: ffmpeg not found, saved as WAV in ${outputPath}`);
+    } else {
+      await convertAudioFormat(wavWorkPath, outputPath);
+      try { fs.unlinkSync(wavWorkPath); } catch { /* ignore */ }
+    }
+  }
+
+  const quotaUsed = (scriptPath ? 0 : 2) + (ttsCallCount ?? segments.length);
+  console.log(`\n=== Done ===`);
+  console.log(`Output: ${outputPath} (${(fs.statSync(outputPath).size / 1024).toFixed(1)} KB, ${duration.toFixed(1)}s)`);
+  console.log(`Script: ${textPath}`);
+  console.log(`Quota:  ${quotaUsed} used, ${lastQuota?.remaining ?? '?'} remaining`);
+
+  return { outputPath, textPath, duration, quotaUsed };
+}
+
+/**
+ * Load a .podcast.json and synthesize from it.
+ */
+async function _podcastFromFile(opts) {
+  if (!opts.token) {
+    throw new Error('Authentication required. Run `voxflow login` first.');
+  }
+
+  const inputPath = path.resolve(opts.input);
+  if (!fs.existsSync(inputPath)) {
+    throw new Error(`Input file not found: ${inputPath}`);
+  }
+
+  console.log(`\n=== Loading podcast from ${inputPath} ===`);
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(inputPath, 'utf8'));
+  } catch (err) {
+    throw new Error(`Invalid JSON in input file ${inputPath}: ${err.message}`);
+  }
+
+  const script = raw.script;
+  const voiceMapping = raw.voiceMapping || {};
+  const segments = parseStructuredScript(script) ||
+    (script?.dialogue || []).map(s => ({ speaker: s.speaker, text: s.text }));
+
+  if (segments.length === 0) {
+    throw new Error('No dialogue segments found in input file');
+  }
+
+  const speed = opts.speed ?? PODCAST_DEFAULTS.speed;
+  const silence = opts.silence ?? PODCAST_DEFAULTS.silence;
+  const pace = opts.pace || 'natural';
+  const silenceExplicit = opts.silence != null;
+
+  let outputPath = opts.output;
+  if (!outputPath) {
+    const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    outputPath = path.resolve(`podcast-${ts}.wav`);
+  }
+
+  const speakers = [...new Set(segments.map(s => s.speaker))];
+  console.log(`    ${segments.length} segments, ${speakers.length} speakers`);
+
+  const { pcmBuffers, quota: lastQuota, ttsCallCount } = await synthesizeAll(opts.api, opts.token, segments, voiceMapping, speed, undefined, { pace });
+
+  console.log('\n[3/3] Building audio...');
+  const gapsMs = silenceExplicit
+    ? null
+    : computeGapsMs(segments, { pace });
+  const { wav, duration } = buildWav(pcmBuffers, gapsMs ? { gapsMs, fadeIn: true } : silence);
+
+  const outDir = path.dirname(outputPath);
+  fs.mkdirSync(outDir, { recursive: true });
+
+  const outputExt = path.extname(outputPath).toLowerCase();
+  const needsConvert = outputExt !== '.wav';
+
+  if (needsConvert) {
+    const tempWavPath = outputPath.slice(0, -outputExt.length) + '.tmp.wav';
+    fs.writeFileSync(tempWavPath, wav);
+
+    const { checkFfmpeg, convertAudioFormat } = require('../../core/ffmpeg');
+    const ffmpegInfo = await checkFfmpeg();
+    if (!ffmpegInfo.available) {
+      fs.renameSync(tempWavPath, outputPath);
+      console.log(`\n    Warning: ffmpeg not found, saved as WAV in ${outputPath}`);
+    } else {
+      await convertAudioFormat(tempWavPath, outputPath);
+      try { fs.unlinkSync(tempWavPath); } catch { /* ignore */ }
+    }
+  } else {
+    fs.writeFileSync(outputPath, wav);
+  }
+
+  const textPath = outputPath.slice(0, -outputExt.length) + '.txt';
+  const textContent = segments.map((s, i) => `[${i + 1}] ${s.speaker}：${s.text}`).join('\n\n');
+  fs.writeFileSync(textPath, textContent, 'utf8');
+
+  console.log(`\n=== Done ===`);
+  console.log(`Output: ${outputPath} (${(fs.statSync(outputPath).size / 1024).toFixed(1)} KB, ${duration.toFixed(1)}s)`);
+  console.log(`Script: ${textPath}`);
+  const calls = ttsCallCount ?? segments.length;
+  console.log(`Quota:  ${calls} TTS calls, ${lastQuota?.remaining ?? '?'} remaining`);
+
+  return { outputPath, textPath, duration, quotaUsed: calls };
+}
+
+// ─── CLI Handler ────────────────────────────────────────────────────────────
+
+async function handle(args) {
+  const { parseFlag, parseIntFlag, parseFloatFlag, parseBoolFlag, validateSpeed, validateSilence, runWithRetry } = require('../../core/args');
+  const { getToken, getTokenInfo } = require('../../core/auth');
+  const { API_BASE } = require('../../core/config');
+
+  const api = parseFlag(args, '--api') || API_BASE;
+  const explicitToken = parseFlag(args, '--token');
+
+  const noTts = parseBoolFlag(args, '--no-tts');
+  const inputFile = parseFlag(args, '--input');
+
+  const exchanges = parseIntFlag(args, '--exchanges');
+  const speed = parseFloatFlag(args, '--speed');
+  const silence = parseFloatFlag(args, '--silence');
+  const pace = parseFlag(args, '--pace');
+  const ducking = parseFloatFlag(args, '--ducking');
+  const output = parseFlag(args, '--output', '-o');
+  const speakersCount = parseIntFlag(args, '--speakers');
+
+  if (pace && !VALID_PACE.includes(pace)) {
+    console.error(`Error: --pace must be one of: ${VALID_PACE.join(', ')} (got: "${pace}")`);
+    process.exit(1);
+  }
+
+  if (exchanges !== undefined) {
+    if (isNaN(exchanges) || exchanges < 2 || exchanges > 30) {
+      console.error(`Error: --exchanges must be an integer between 2 and 30 (got: "${parseFlag(args, '--exchanges')}")`);
+      process.exit(1);
+    }
+  }
+
+  validateSpeed(args, speed);
+  validateSilence(args, silence);
+
+  if (output) {
+    const validExts = ['.wav', '.mp3', '.txt', '.json'];
+    const hasValidExt = validExts.some(ext => output.toLowerCase().endsWith(ext));
+    if (!hasValidExt) {
+      console.error(`Error: --output path must end with ${validExts.join(', ')}`);
+      process.exit(1);
+    }
+  }
+
+  const length = parseFlag(args, '--length');
+  if (length && !['short', 'medium', 'long'].includes(length)) {
+    console.error(`Error: --length must be one of: short, medium, long (got: "${length}")`);
+    process.exit(1);
+  }
+
+  const engine = parseFlag(args, '--engine');
+  if (engine && !['auto', 'legacy', 'ai-sdk'].includes(engine)) {
+    console.error(`Error: --engine must be one of: auto, legacy, ai-sdk (got: "${engine}")`);
+    process.exit(1);
+  }
+
+  const colloquial = parseFlag(args, '--colloquial');
+  if (colloquial && !['low', 'medium', 'high'].includes(colloquial)) {
+    console.error(`Error: --colloquial must be one of: low, medium, high (got: "${colloquial}")`);
+    process.exit(1);
+  }
+
+  if (speakersCount !== undefined) {
+    if (isNaN(speakersCount) || speakersCount < 1 || speakersCount > 3) {
+      console.error(`Error: --speakers must be 1, 2, or 3 (got: "${parseFlag(args, '--speakers')}")`);
+      process.exit(1);
+    }
+  }
+
+  const languageRaw = parseFlag(args, '--language', '--lang');
+  const langAlias = { zh: 'zh-CN', 'en-US': 'en', 'ja-JP': 'ja' };
+  const language = languageRaw ? (langAlias[languageRaw] || languageRaw) : null;
+  if (language && !['zh-CN', 'en', 'ja'].includes(language)) {
+    console.error(`Error: --language must be one of: zh-CN, en, ja (got: "${languageRaw}")`);
+    process.exit(1);
+  }
+
+  const template = parseFlag(args, '--template');
+  if (template && !['interview', 'discussion', 'news', 'story', 'tutorial'].includes(template)) {
+    console.error(`Error: --template must be one of: interview, discussion, news, story, tutorial (got: "${template}")`);
+    process.exit(1);
+  }
+
+  const format = parseFlag(args, '--format');
+  if (format && !['json'].includes(format)) {
+    console.error(`Error: --format must be: json (got: "${format}")`);
+    process.exit(1);
+  }
+
+  if (inputFile) {
+    const resolved = path.resolve(inputFile);
+    if (!fs.existsSync(resolved)) {
+      console.error(`Error: Input file not found: ${resolved}`);
+      process.exit(1);
+    }
+  }
+
+  const script = parseFlag(args, '--script');
+  if (script) {
+    const resolved = path.resolve(script);
+    if (!fs.existsSync(resolved)) {
+      console.error(`Error: Script file not found: ${resolved}`);
+      process.exit(1);
+    }
+  }
+
+  const bgm = parseFlag(args, '--bgm');
+  if (bgm) {
+    const resolved = path.resolve(bgm);
+    if (!fs.existsSync(resolved)) {
+      console.error(`Error: BGM file not found: ${resolved}`);
+      process.exit(1);
+    }
+  }
+
+  if (ducking !== undefined) {
+    if (isNaN(ducking) || ducking < 0 || ducking > 1.0) {
+      console.error(`Error: --ducking must be between 0 and 1.0 (got: "${parseFlag(args, '--ducking')}")`);
+      process.exit(1);
+    }
+  }
+
+  let token;
+  if (explicitToken) {
+    token = explicitToken;
+  } else {
+    token = await getToken({ api });
+    const info = getTokenInfo();
+    if (info) {
+      console.log(`\x1b[32mLogged in as ${info.email}\x1b[0m`);
+    }
+  }
+
+  let topic = parseFlag(args, '--topic');
+  if (!topic) {
+    const valuedFlags = new Set([
+      '--topic', '--engine', '--template', '--style', '--colloquial',
+      '--speakers', '--language', '--lang', '--length', '--exchanges',
+      '--format', '--input', '--script', '--voice', '--bgm', '--ducking',
+      '--output', '-o', '--speed', '--silence', '--pace', '--api', '--token',
+    ]);
+    for (let i = 0; i < args.length; i++) {
+      if (args[i].startsWith('-')) {
+        if (valuedFlags.has(args[i])) i++;
+        continue;
+      }
+      topic = args[i];
+      break;
+    }
+  }
+
+  const podcastOpts = {
+    token, api,
+    topic,
+    style: parseFlag(args, '--style') || template,
+    template,
+    length,
+    exchanges,
+    output, speed, silence,
+    pace: pace || undefined,
+    engine: engine || undefined,
+    colloquial: colloquial || undefined,
+    speakers: speakersCount || undefined,
+    language: language || undefined,
+    format: format || undefined,
+    input: inputFile || undefined,
+    noTts,
+    voice: parseFlag(args, '--voice'),
+    script,
+    bgm,
+    ducking,
+  };
+
+  await runWithRetry(podcast, podcastOpts, api, explicitToken);
+}
+
+const meta = {
+  podcast: {
+    usage: '[topic] [opts]',
+    description: 'Generate a multi-speaker podcast/dialogue',
+    options: [
+      `<topic>              Podcast topic (positional arg or --topic)`,
+      `--topic <text>       Podcast topic (alternative to positional, default: tech trends)`,
+      `--engine <type>      auto | legacy | ai-sdk (default: auto → ai-sdk)`,
+      `--template <name>    interview | discussion | news | story | tutorial`,
+      `--colloquial <lvl>   low | medium | high (default: medium)`,
+      `--speakers <n>       Speaker count: 1, 2, or 3 (default: ${PODCAST_DEFAULTS.speakers})`,
+      `--language <code>    zh-CN | en | ja (alias: --lang; accepts zh, en-US, ja-JP)`,
+      `--style <style>      Legacy: dialogue style (maps to --template)`,
+      `--length <len>       short | medium | long (default: ${PODCAST_DEFAULTS.length})`,
+      `--exchanges <n>      Number of exchanges, 2-30 (legacy, default: ${PODCAST_DEFAULTS.exchanges})`,
+      `--format json        Output .podcast.json alongside audio`,
+      `--input <file>       Load .podcast.json and synthesize from it`,
+      `--no-tts             Generate script only, skip TTS synthesis`,
+      `--script <file>      Pre-written script JSON (skips LLM generation)`,
+      `--voice <id>         Override TTS voice for all speakers`,
+      `--bgm <file>         Background music file to mix in`,
+      `--ducking <n>        BGM volume ducking 0-1.0 (default: ${PODCAST_DEFAULTS.ducking})`,
+      `--output <path>      Output WAV path (default: ./podcast-<timestamp>.wav)`,
+      `--speed <n>          TTS speed 0.5-2.0 (default: ${PODCAST_DEFAULTS.speed})`,
+      `--silence <sec>      Uniform silence override between segments, 0-5.0 (legacy)`,
+      `--pace <preset>      Pacing preset: tight | natural | relaxed (default: natural).`,
+      `                     Multiplies intent-driven per-segment gaps. Ignored if --silence is set.`,
+    ],
+    examples: [
+      'voxflow podcast "远程工作让人更累的三个原因"',
+      'voxflow podcast --topic "AI in healthcare"',
+      'voxflow podcast "climate change" --colloquial high --speakers 3',
+      'voxflow podcast "tech news" --template news --lang en',
+      'voxflow podcast --topic "AI" --format json --no-tts',
+      'voxflow podcast --input podcast.podcast.json',
+      'voxflow podcast --topic "debate" --engine legacy --length long --exchanges 20',
+      'voxflow podcast --script dialogue.json --voice v-male-Bk7vD3xP',
+      'voxflow podcast --topic "music history" --bgm background.mp3 --ducking 0.15',
+      'voxflow podcast "AI" --pace relaxed   # slower, more breathing room',
+      'voxflow podcast "AI" --pace tight     # snappy, tighter cadence',
+    ],
+  },
+};
+
+const { parseDialogueText } = require('./dialogue');
+
+module.exports = { podcast, handle, meta, ApiError, _test: { parseDialogueText, parseStructuredScript, resolveEngine, loadScript } };