voxflow 1.15.0 → 1.15.2

package/lib/commands/publish.js

@@ -0,0 +1,415 @@
+/**
+ * VoxFlow CLI — Publish command
+ *
+ * Single-command delivery entrypoint for Skill/Web orchestration:
+ *   - mode A: video-translate -> final MP4 -> publish
+ *   - mode B: SRT + video dub -> final MP4 -> publish
+ *   - mode C: merge existing video + audio -> final MP4 -> publish
+ *
+ * Publish targets:
+ *   - local   (default): copy artifact to publish directory
+ *   - webhook: call external publisher service and return URL
+ *   - none: no publish step, return final MP4 only
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { API_BASE } = require('../core/config');
+const { request } = require('../core/http');
+const { videoTranslate } = require('./video-translate');
+const { dub } = require('./dub');
+const { mergeAudioVideo, getAudioDuration } = require('../core/ffmpeg');
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function defaultOutputPath(videoPath) {
+  const base = path.basename(videoPath, path.extname(videoPath));
+  const fname = base + '-published.mp4';
+  return path.resolve(path.dirname(videoPath), fname);
+}
+
+function defaultPublishDir() {
+  return path.resolve(process.cwd(), 'published');
+}
+
+/** 将绝对路径转为 file:// URL（兼容 Windows 三斜杠格式） */
+function toFileUrl(absPath) {
+  const normalized = absPath.split(path.sep).join('/');
+  // Unix: /tmp/a.mp4 → file:///tmp/a.mp4 ; Windows: C:/a.mp4 → file:///C:/a.mp4
+  return normalized.startsWith('/') ? `file://${normalized}` : `file:///${normalized}`;
+}
+
+function copyToPublishDir(srcPath, publishDir, platform) {
+  ensureDir(publishDir);
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  const base = path.basename(srcPath, path.extname(srcPath));
+  const targetName = `${base}-${platform}-${ts}.mp4`;
+  const targetPath = path.join(publishDir, targetName);
+  fs.copyFileSync(srcPath, targetPath);
+
+  return {
+    target: 'local',
+    platform,
+    status: 'ready',
+    publishedPath: targetPath,
+    publishUrl: toFileUrl(targetPath),
+  };
+}
+
+async function publishToWebhook(webhook, payload) {
+  // Validate webhook URL
+  const parsedUrl = new URL(webhook); // will throw if invalid
+  if (parsedUrl.protocol !== 'https:' && parsedUrl.protocol !== 'http:') {
+    throw new Error('Webhook URL must use HTTP or HTTPS');
+  }
+  // Block private/internal IPs
+  const hostname = parsedUrl.hostname;
+  if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '0.0.0.0' || hostname === '::1' ||
+      hostname.startsWith('10.') || hostname.startsWith('192.168.') ||
+      hostname.match(/^172\.(1[6-9]|2\d|3[01])\./) ||
+      hostname === '169.254.169.254' || hostname.startsWith('169.254.') ||
+      hostname.startsWith('fd') || hostname.startsWith('fc') || hostname.startsWith('fe80') ||
+      hostname.endsWith('.internal') || hostname.endsWith('.local')) {
+    throw new Error('Webhook URL must not target private networks');
+  }
+
+  const { status, data } = await request(webhook, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+  }, payload);
+
+  if (status >= 400) {
+    throw new Error(`Webhook publish failed (${status}): ${data?.message || JSON.stringify(data)}`);
+  }
+
+  return {
+    target: 'webhook',
+    status: data.status || 'submitted',
+    platform: data.platform || payload.platform,
+    publishUrl: data.publishUrl || data.url || null,
+    platformJobId: data.jobId || null,
+    raw: data,
+  };
+}
+
+async function publish(opts) {
+  const sigintHandler = () => {
+    console.log('\n\nPublish cancelled.');
+    process.exit(130);
+  };
+  process.on('SIGINT', sigintHandler);
+
+  try {
+    return await _publish(opts);
+  } finally {
+    process.removeListener('SIGINT', sigintHandler);
+  }
+}
+
+async function _publish(opts) {
+  const {
+    token,
+    api = API_BASE,
+    // Mode A
+    input,
+    from,
+    to,
+    // Mode B
+    srt,
+    // Mode B/C
+    video,
+    // Mode C
+    audio,
+    // Shared media options
+    voice,
+    voicesMap,
+    speed,
+    realign = false,
+    batchSize,
+    keepIntermediates = false,
+    output,
+    // Publish options
+    publishTarget = 'local',
+    publishDir = defaultPublishDir(),
+    publishWebhook,
+    platform = 'generic',
+    title,
+  } = opts;
+
+  const modeVideoTranslate = !!(input && to);
+  const modeDub = !!(srt && video);
+  const modeMerge = !!(video && audio);
+
+  const selectedModes = [modeVideoTranslate, modeDub, modeMerge].filter(Boolean).length;
+  if (selectedModes !== 1) {
+    throw new Error(
+      'Invalid publish input. Use exactly one mode:\n' +
+      '  1) --input <video> --to <lang>            (video-translate + publish)\n' +
+      '  2) --srt <file> --video <video>           (dub + publish)\n' +
+      '  3) --video <video> --audio <audio>        (merge existing + publish)'
+    );
+  }
+
+  if (!['local', 'webhook', 'none'].includes(publishTarget)) {
+    throw new Error(`--publish must be one of: local, webhook, none (got: ${publishTarget})`);
+  }
+  if (publishTarget === 'webhook' && !publishWebhook) {
+    throw new Error('--publish webhook requires --publish-webhook <url>');
+  }
+
+  console.log('\n=== VoxFlow Publish ===');
+  console.log(`Publish target: ${publishTarget}`);
+  console.log(`Platform:       ${platform}`);
+
+  let finalVideoPath;
+  let buildMode;
+  let buildResult = {};
+
+  if (modeVideoTranslate) {
+    if (!token) {
+      throw new Error('Publish mode "video-translate" requires authentication token');
+    }
+    console.log('Build mode:     video-translate');
+    const result = await videoTranslate({
+      token,
+      api,
+      input,
+      from,
+      to,
+      voice,
+      voicesMap,
+      output: output ? path.resolve(output) : undefined,
+      realign,
+      batchSize,
+      keepIntermediates,
+      speed,
+    });
+    finalVideoPath = result.outputPath;
+    buildMode = 'video-translate';
+    buildResult = result;
+  } else if (modeDub) {
+    if (!token) {
+      throw new Error('Publish mode "srt-dub" requires authentication token');
+    }
+    console.log('Build mode:     srt-dub');
+    const result = await dub({
+      token,
+      api,
+      srt,
+      video,
+      voice,
+      voicesMap,
+      speed,
+      output: output ? path.resolve(output) : undefined,
+    });
+    finalVideoPath = result.outputPath;
+    buildMode = 'srt-dub';
+    buildResult = result;
+  } else {
+    console.log('Build mode:     merge-existing');
+    finalVideoPath = output ? path.resolve(output) : defaultOutputPath(path.resolve(video));
+    await mergeAudioVideo(video, audio, finalVideoPath);
+    buildMode = 'merge-existing';
+    buildResult = { outputPath: finalVideoPath, quotaUsed: 0 };
+  }
+
+  const resolvedFinal = path.resolve(finalVideoPath);
+  const fileStat = fs.statSync(resolvedFinal);
+  const durationMs = await getAudioDuration(resolvedFinal);
+  const jobId = `pub_${crypto.randomUUID()}`;
+
+  const meta = {
+    jobId,
+    title: title || path.basename(resolvedFinal, path.extname(resolvedFinal)),
+    buildMode,
+    platform,
+    createdAt: new Date().toISOString(),
+    artifact: {
+      localPath: resolvedFinal,
+      sizeBytes: fileStat.size,
+      durationSec: Number((durationMs / 1000).toFixed(2)),
+    },
+  };
+
+  let publishResult = {
+    target: 'none',
+    status: 'skipped',
+    platform,
+    publishUrl: null,
+  };
+
+  if (publishTarget === 'local') {
+    publishResult = copyToPublishDir(resolvedFinal, path.resolve(publishDir), platform);
+  } else if (publishTarget === 'webhook') {
+    const { localPath: _localPath, ...artifactSafe } = meta.artifact;
+    publishResult = await publishToWebhook(publishWebhook, {
+      ...meta,
+      artifact: {
+        ...artifactSafe,
+        filePath: path.basename(meta.artifact.localPath),
+      },
+    });
+  }
+
+  const result = {
+    ...meta,
+    publish: publishResult,
+    quotaUsed: buildResult.quotaUsed || 0,
+    buildResult,
+  };
+
+  console.log('\n=== Publish Done ===');
+  console.log(`Final video:    ${resolvedFinal}`);
+  console.log(`Duration:       ${result.artifact.durationSec}s`);
+  console.log(`Size:           ${(result.artifact.sizeBytes / 1024 / 1024).toFixed(2)} MB`);
+  console.log(`Publish status: ${publishResult.status}`);
+  if (publishResult.publishUrl) {
+    console.log(`Publish URL:    ${publishResult.publishUrl}`);
+  } else if (publishResult.publishedPath) {
+    console.log(`Published file: ${publishResult.publishedPath}`);
+  }
+
+  return result;
+}
+
+// ─── CLI Handler ────────────────────────────────────────────────────────────
+
+async function handle(args) {
+  const { parseFlag, parseIntFlag, parseFloatFlag, parseBoolFlag, validateSpeed, assertFileExists, runWithRetry } = require('../core/args');
+  const { getToken, getTokenInfo } = require('../core/auth');
+  const { API_BASE, getConfigDir } = require('../core/config');
+  const { warnIfMissingFfmpeg } = require('../core/ffmpeg');
+
+  // Check FFmpeg availability (one-time hint)
+  await warnIfMissingFfmpeg(getConfigDir(), 'dub');
+
+  const api = parseFlag(args, '--api') || API_BASE;
+  const explicitToken = parseFlag(args, '--token');
+
+  const input = parseFlag(args, '--input');
+  const to = parseFlag(args, '--to');
+  const video = parseFlag(args, '--video');
+  const srt = parseFlag(args, '--srt');
+  const audio = parseFlag(args, '--audio');
+  const output = parseFlag(args, '--output', '-o');
+  const publishTarget = parseFlag(args, '--publish') || 'local';
+  const publishWebhook = parseFlag(args, '--publish-webhook');
+
+  // 文件存在性在 CLI 层检查（友好 exit），业务校验由 publish() 统一处理
+  if (input) assertFileExists(input, 'Input video');
+  if (video) assertFileExists(video, 'Video');
+  if (srt) assertFileExists(srt, 'SRT');
+  if (audio) assertFileExists(audio, 'Audio');
+
+  // publish target 校验（快速 fail，避免进入 publish 后才报错）
+  if (publishTarget && !['local', 'webhook', 'none'].includes(publishTarget)) {
+    console.error(`Error: --publish must be one of: local, webhook, none (got: "${publishTarget}")`);
+    process.exit(1);
+  }
+  if (publishTarget === 'webhook' && !publishWebhook) {
+    console.error('Error: --publish webhook requires --publish-webhook <url>');
+    process.exit(1);
+  }
+
+  if (output && !output.toLowerCase().endsWith('.mp4')) {
+    console.error('Error: --output path must end with .mp4');
+    process.exit(1);
+  }
+
+  // Validate speed and batch-size
+  const speed = parseFloatFlag(args, '--speed');
+  validateSpeed(args, speed);
+
+  const batchSize = parseIntFlag(args, '--batch-size');
+  if (batchSize !== undefined && (isNaN(batchSize) || batchSize < 1 || batchSize > 20)) {
+    console.error(`Error: --batch-size must be between 1 and 20 (got: "${parseFlag(args, '--batch-size')}")`);
+    process.exit(1);
+  }
+
+  // merge-existing 模式不需要 API 调用，其他模式需要认证
+  const isMergeOnly = !!(video && audio && !srt && !input);
+  let token = null;
+  if (!isMergeOnly) {
+    if (explicitToken) {
+      token = explicitToken;
+    } else {
+      token = await getToken({ api });
+      const info = getTokenInfo();
+      if (info) {
+        console.log(`\x1b[32mLogged in as ${info.email}\x1b[0m`);
+      }
+    }
+  }
+
+  const opts = {
+    token,
+    api,
+    input,
+    from: parseFlag(args, '--from'),
+    to,
+    srt,
+    video,
+    audio,
+    voice: parseFlag(args, '--voice'),
+    voicesMap: parseFlag(args, '--voices'),
+    output,
+    speed,
+    realign: parseBoolFlag(args, '--realign'),
+    keepIntermediates: parseBoolFlag(args, '--keep-intermediates'),
+    batchSize,
+    publishTarget,
+    publishDir: parseFlag(args, '--publish-dir'),
+    publishWebhook,
+    platform: parseFlag(args, '--platform') || undefined,
+    title: parseFlag(args, '--title') || undefined,
+  };
+
+  try {
+    const result = isMergeOnly
+      ? await publish(opts)
+      : await runWithRetry(publish, opts, api, explicitToken);
+
+    if (parseBoolFlag(args, '--json')) {
+      console.log(JSON.stringify(result, null, 2));
+    }
+  } catch (err) {
+    const msg = err.message || err.code || String(err);
+    console.error(`\nFatal error: ${msg}`);
+    process.exit(1);
+  }
+}
+
+const meta = {
+  publish: {
+    usage: '[opts]',
+    description: 'One-command build+merge+publish for Skill/Web orchestration',
+    options: [
+      '--input <video>      Mode A: video-translate then publish (requires --to)',
+      '--to <lang>          Target language for Mode A',
+      '--from <lang>        Source language for Mode A (default: auto)',
+      '--srt <file>         Mode B: dub existing subtitles into video (requires --video)',
+      '--video <file>       Video file for Mode B/Mode C',
+      '--audio <file>       Mode C: merge existing audio into video',
+      '--voice <id>         TTS voice for Mode A/B',
+      '--voices <file>      Multi-speaker voice map for Mode A/B',
+      '--output <path>      Final MP4 output path',
+      '--publish <target>   local (default) | webhook | none',
+      '--publish-dir <dir>  Local publish directory (for --publish local)',
+      '--publish-webhook <url> Webhook URL (for --publish webhook)',
+      '--platform <name>    Platform metadata tag (default: generic)',
+      '--title <text>       Title metadata',
+      '--json               Print structured JSON result (recommended for skills)',
+    ],
+    examples: [
+      'voxflow publish --input video.mp4 --to en --publish local',
+      'voxflow publish --srt captions.srt --video input.mp4 --publish local',
+      'voxflow publish --video input.mp4 --audio narration.mp3 --publish local',
+      'voxflow publish --input video.mp4 --to ja --publish webhook --publish-webhook https://publisher.example.com/hook --json',
+    ],
+  },
+};
+
+module.exports = { publish, handle, meta };