feat: 添加视频拆解合成功能

- 新增视频拆解API接口，支持根据字幕拆解视频片段
- 实现视频片段合成功能，可生成带字幕的完整合成视频
- 添加ffmpeg集成，支持视频处理和字幕嵌入
- 集成OSS存储，自动上传处理结果
- 支持任务进度跟踪和状态管理
- 添加createCompilation参数控制是否生成合成视频

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: aixier

terminal-backend/ffmpeg

@@ -0,0 +1 @@
+/usr/bin/ffmpeg

terminal-backend/src/config/config.js

@@ -1,24 +1,145 @@
+import fs from 'fs'
+import path from 'path'
 import dotenv from 'dotenv'
+
 dotenv.config()
 
+const toNumber = (value, fallback) => {
+  const parsed = parseInt(value, 10)
+  return Number.isNaN(parsed) ? fallback : parsed
+}
+
+const parseArgs = value => {
+  if (!value) return null
+  return value
+    .split(/\s+/)
+    .map(item => item.trim())
+    .filter(Boolean)
+}
+
+const parseOptional = value => (value && value.trim()) || null
+
+const resolvePath = (value, fallback) => {
+  if (!value) return fallback
+  return path.isAbsolute(value) ? value : path.join(process.cwd(), value)
+}
+
+const ensureDir = dir => {
+  try {
+    fs.mkdirSync(dir, { recursive: true })
+  } catch (error) {
+    console.warn(`[config] Could not ensure directory ${dir}: ${error.message}`)
+  }
+}
+
+const workspaceRoot = resolvePath(
+  process.env.YOUTUBE2POST_WORKSPACE_ROOT,
+  path.join(process.cwd(), 'terminal-backend/data/users/default/workspace/card')
+)
+const tempRoot = resolvePath(
+  process.env.YOUTUBE2POST_TEMP_ROOT,
+  path.join(process.cwd(), 'terminal-backend/data/tmp/youtube2post')
+)
+const dataRoot = resolvePath(
+  process.env.YOUTUBE2POST_DATA_ROOT,
+  path.join(process.cwd(), 'terminal-backend/data/youtube2post')
+)
+const templateRoot = resolvePath(
+  process.env.YOUTUBE2POST_TEMPLATE_ROOT,
+  path.join(process.cwd(), 'terminal-backend/data/public_template/youtube2post')
+)
+
+ensureDir(workspaceRoot)
+ensureDir(tempRoot)
+ensureDir(dataRoot)
+
+const videoDecomposeWorkspaceRoot = resolvePath(
+  process.env.VIDEO_DECOMPOSE_WORKSPACE_ROOT,
+  path.join(process.cwd(), 'terminal-backend/data/users/default/workspace/video-decompose')
+)
+const videoDecomposeTempRoot = resolvePath(
+  process.env.VIDEO_DECOMPOSE_TEMP_ROOT,
+  path.join(process.cwd(), 'terminal-backend/data/tmp/video-decompose')
+)
+const videoDecomposeOutputRoot = resolvePath(
+  process.env.VIDEO_DECOMPOSE_OUTPUT_ROOT,
+  path.join(process.cwd(), 'terminal-backend/data/video-decompose')
+)
+
+ensureDir(videoDecomposeWorkspaceRoot)
+ensureDir(videoDecomposeTempRoot)
+ensureDir(videoDecomposeOutputRoot)
+
+const youtube2postConfig = {
+  workerEnabled: process.env.YOUTUBE2POST_WORKER_ENABLED !== 'false',
+  maxConcurrentTasks: toNumber(process.env.YOUTUBE2POST_MAX_CONCURRENT, 1),
+  maxPendingTasks: toNumber(process.env.YOUTUBE2POST_MAX_PENDING, 20),
+  pollIntervalMs: toNumber(process.env.YOUTUBE2POST_POLL_INTERVAL_MS, 5000),
+  lockTtlMs: toNumber(process.env.YOUTUBE2POST_LOCK_TTL_MS, 10 * 60 * 1000),
+  youtubeDlPath: process.env.YOUTUBE2POST_YOUTUBE_DL_PATH || path.join(process.cwd(), 'youtube-dl', 'bin', 'youtube-dl'),
+  downloadTimeoutMs: toNumber(process.env.YOUTUBE2POST_DOWNLOAD_TIMEOUT_MS, 10 * 60 * 1000),
+  youtubeDlArgs: parseArgs(process.env.YOUTUBE2POST_YOUTUBE_DL_ARGS) || ['-f', 'best'],
+  ffmpegPath: process.env.YOUTUBE2POST_FFMPEG_PATH || 'ffmpeg',
+  maxQuotes: toNumber(process.env.YOUTUBE2POST_MAX_QUOTES, 5),
+  frameExtractionTimeoutMs: toNumber(process.env.YOUTUBE2POST_FRAME_TIMEOUT_MS, 60 * 1000),
+  frameQuality: toNumber(process.env.YOUTUBE2POST_FRAME_QUALITY, 2),
+  frameScaleFilter: parseOptional(process.env.YOUTUBE2POST_FRAME_SCALE_FILTER),
+  transcriptionPollIntervalMs: toNumber(process.env.YOUTUBE2POST_TRANSCRIPTION_POLL_MS, 5000),
+  transcriptionMaxAttempts: toNumber(process.env.YOUTUBE2POST_TRANSCRIPTION_MAX_ATTEMPTS, 120),
+  ossEnabled: process.env.YOUTUBE2POST_OSS_ENABLED === 'true',
+  ossProject: process.env.YOUTUBE2POST_OSS_PROJECT || 'youtube2post',
+  ossBaseDir: process.env.YOUTUBE2POST_OSS_BASE_DIR || 'youtube2post',
+  publicBaseUrl: process.env.YOUTUBE2POST_PUBLIC_BASE_URL || null,
+  workspaceRoot,
+  tempRoot,
+  dataRoot,
+  templateRoot
+}
+
+const videoDecomposeConfig = {
+  ffmpegPath: process.env.VIDEO_DECOMPOSE_FFMPEG_PATH
+    || process.env.YOUTUBE2POST_FFMPEG_PATH
+    || 'ffmpeg',
+  screenshotQuality: toNumber(process.env.VIDEO_DECOMPOSE_SCREENSHOT_QUALITY, 2),
+  frameScaleFilter: parseOptional(process.env.VIDEO_DECOMPOSE_FRAME_SCALE_FILTER),
+  clipPreset: process.env.VIDEO_DECOMPOSE_FFMPEG_PRESET || 'fast',
+  clipCrf: toNumber(process.env.VIDEO_DECOMPOSE_FFMPEG_CRF, 23),
+  maxHighlights: toNumber(process.env.VIDEO_DECOMPOSE_MAX_HIGHLIGHTS, 5),
+  minQuoteLength: toNumber(process.env.VIDEO_DECOMPOSE_MIN_QUOTE_LENGTH, 12),
+  clipPaddingSeconds: Number.isNaN(Number(process.env.VIDEO_DECOMPOSE_CLIP_PADDING))
+    ? 0.5
+    : Number(process.env.VIDEO_DECOMPOSE_CLIP_PADDING),
+  ossBaseDir: process.env.VIDEO_DECOMPOSE_OSS_BASE_DIR || 'video-decompose',
+  keepTemp: process.env.VIDEO_DECOMPOSE_KEEP_TEMP === 'true',
+  workspaceRoot: videoDecomposeWorkspaceRoot,
+  tempRoot: videoDecomposeTempRoot,
+  outputRoot: videoDecomposeOutputRoot
+}
+
 export default {
   port: process.env.PORT || 6000,
   nodeEnv: process.env.NODE_ENV || 'development',
-  
+
   jwt: {
     secret: process.env.JWT_SECRET || 'default-secret',
     expireTime: process.env.JWT_EXPIRE_TIME || '24h'
   },
-  
+
+  aliyun: {
+    apiKey: process.env.DASHSCOPE_API_KEY
+      || process.env.ALIYUN_API_KEY
+      || 'sk-4c89a24b73d24731b86bf26337398cef'
+  },
+
   terminal: {
-    maxSessions: parseInt(process.env.MAX_TERMINAL_SESSIONS) || 10,
-    timeout: parseInt(process.env.TERMINAL_TIMEOUT) || 600000
+    maxSessions: toNumber(process.env.MAX_TERMINAL_SESSIONS, 10),
+    timeout: toNumber(process.env.TERMINAL_TIMEOUT, 600000)
   },
-  
+
   cors: {
     origins: process.env.ALLOWED_ORIGINS?.split(',') || [
-      'http://localhost:5173', 
-      'http://localhost:5174', 
+      'http://localhost:5173',
+      'http://localhost:5174',
       'http://localhost:6000',
       'http://127.0.0.1:5173',
       'http://127.0.0.1:5174',
@@ -34,16 +155,45 @@ export default {
       'http://card.paitongai.com',
       'https://card.paitongai.com',
       'http://card.paitongai.com:80',
-      'http://cardapi.paitongai.com',      // 新增API域名
-      'https://cardapi.paitongai.com',     // 新增API域名HTTPS
-      'http://aicard.paitongai.com',       // AI卡片域名
-      'https://aicard.paitongai.com',      // AI卡片域名HTTPS
+      'http://cardapi.paitongai.com',
+      'https://cardapi.paitongai.com',
+      'http://aicard.paitongai.com',
+      'https://aicard.paitongai.com',
       'http://ai-terminal-xnbmzvtedv.ap-northeast-1.fcapp.run',
       'https://ai-terminal-xnbmzvtedv.ap-northeast-1.fcapp.run'
     ]
   },
-  
+
   logging: {
     level: process.env.LOG_LEVEL || 'info'
-  }
-}
+  },
+
+  llm: {
+    qwen: {
+      enabled: true,
+      apiKey: process.env.QWEN_API_KEY || 'sk-4c89a24b73d24731b86bf26337398cef',
+      baseUrl: 'https://dashscope.aliyuncs.com/api/v1',
+      model: 'qwen-max',
+      temperature: 0.3,
+      maxTokens: 8000,
+      timeout: 90,
+      maxRetries: 3,
+      retryDelay: 3.0
+    },
+    'qwen-plus': {
+      enabled: true,
+      apiKey: process.env.QWEN_PLUS_API_KEY || 'sk-4c89a24b73d24731b86bf26337398cef',
+      baseUrl: 'https://dashscope.aliyuncs.com/api/v1',
+      model: 'qwen-plus',
+      temperature: 0.3,
+      maxTokens: 8000,
+      timeout: 90,
+      maxRetries: 3,
+      retryDelay: 3.0,
+      description: '阿里云通义千问Plus - 平衡性能和成本'
+    }
+  },
+
+  youtube2post: youtube2postConfig,
+  videoDecompose: videoDecomposeConfig
+}

terminal-backend/src/index.js

@@ -18,6 +18,8 @@ import generateRoutes from './routes/generate/index.js'
 import uploadRoutes from './routes/upload.js'
 import workspaceRoutes from './routes/workspace.js'
 import transcriptionRoutes from './routes/transcription.js'
+import youtube2postRoutes from './routes/youtube2post/index.js'
+import youtubeDownloadRoutes from './routes/youtubeDownload.js'
 import assetsRoutes from './routes/v2/assets.js'
 import { router as sseRouter } from './routes/v2/sse.js'
 import stsRoutes from './routes/sts.js'
@@ -26,6 +28,8 @@ import htmlEditRoutes from './routes/htmlEdit.js'
 import cardExtractorRoutes from './routes/cardExtractor.js'
 import { setupSocketHandlers } from './services/socketService.js'
 import websocketService from './services/websocketService.js'
+import { startYoutube2PostWorker } from './workers/youtube2postProcessor.js'
+import videoDecomposeRoutes from './routes/videoDecompose.js'
 // import { preventCommandInjection, limitRequestSize, auditLog, rateLimit } from './middleware/security.js'
 // import { verifyToken, optionalAuth } from './middleware/auth.js'
 
@@ -285,6 +289,12 @@ console.log('     ✓ /api/workspace route registered')
 
 app.use('/api/transcription', transcriptionRoutes)
 console.log('     ✓ /api/transcription route registered')
+app.use('/api/youtube2post', youtube2postRoutes)
+console.log('     ✓ /api/youtube2post route registered')
+app.use('/api/video-decompose', videoDecomposeRoutes)
+console.log('     ✓ /api/video-decompose route registered')
+app.use('/api/youtube', youtubeDownloadRoutes)
+console.log('     ✓ /api/youtube route registered')
 app.use('/api/sts', stsRoutes)
 console.log('     ✓ /api/sts route registered')
 app.use('/api/oss-direct', ossDirectRoutes)
@@ -612,6 +622,10 @@ httpServer.listen(PORT, HOST, () => {
   logger.info(`Server running on ${HOST}:${PORT} in ${config.nodeEnv} mode`)
   logger.info(`Server is accessible from any network interface`)
   logger.info(`HTTP timeout set to ${TIMEOUT_MS/1000}s for long-running requests`)
+
+  if (config.youtube2post?.workerEnabled !== false) {
+    startYoutube2PostWorker()
+  }
 })
 
-export { io }
+export { io }

terminal-backend/src/routes/videoDecompose.js

@@ -0,0 +1,73 @@
+import express from 'express'
+import logger from '../utils/logger.js'
+import {
+  createVideoDecomposeTask,
+  getVideoDecomposeTask
+} from '../services/videoDecompose/index.js'
+
+const router = express.Router()
+
+router.post('/jobs', (req, res) => {
+  try {
+    const {
+      videoUrl,
+      subtitleUrl,
+      maxHighlights,
+      minQuoteLength,
+      clipPaddingSeconds,
+      createCompilation
+    } = req.body || {}
+
+    if (!videoUrl || !subtitleUrl) {
+      return res.status(400).json({
+        success: false,
+        error: 'videoUrl and subtitleUrl are required'
+      })
+    }
+
+    logger.info('[videoDecompose] Creating job', {
+      videoUrl,
+      subtitleUrl,
+      createCompilation
+    })
+
+    const job = createVideoDecomposeTask({
+      videoUrl,
+      subtitleUrl,
+      options: {
+        maxHighlights: Number(maxHighlights),
+        minQuoteLength: Number(minQuoteLength),
+        clipPaddingSeconds: Number(clipPaddingSeconds),
+        createCompilation: Boolean(createCompilation)
+      }
+    })
+
+    return res.json({
+      success: true,
+      data: job
+    })
+  } catch (error) {
+    logger.error(`[videoDecompose] Failed to create job: ${error.message}`)
+    return res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to create job'
+    })
+  }
+})
+
+router.get('/jobs/:id', (req, res) => {
+  const job = getVideoDecomposeTask(req.params.id)
+  if (!job) {
+    return res.status(404).json({
+      success: false,
+      error: 'Job not found'
+    })
+  }
+
+  return res.json({
+    success: true,
+    data: job
+  })
+})
+
+export default router

terminal-backend/src/services/videoDecompose/index.js

@@ -0,0 +1,51 @@
+import logger from '../../utils/logger.js'
+import {
+  createJob,
+  getJob,
+  getJobInternal,
+  failJob
+} from './jobStore.js'
+import processJob from './processor.js'
+
+const sanitizeOptions = input => {
+  if (!input) return {}
+  const options = {}
+
+  if (Number.isFinite(input.maxHighlights)) {
+    options.maxHighlights = Math.max(1, Math.floor(input.maxHighlights))
+  }
+
+  if (Number.isFinite(input.minQuoteLength)) {
+    options.minQuoteLength = Math.max(1, Math.floor(input.minQuoteLength))
+  }
+
+  if (Number.isFinite(input.clipPaddingSeconds)) {
+    options.clipPaddingSeconds = Math.max(0, Number(input.clipPaddingSeconds))
+  }
+
+  return options
+}
+
+export function createVideoDecomposeTask(payload) {
+  const job = createJob({
+    videoUrl: payload.videoUrl,
+    subtitleUrl: payload.subtitleUrl,
+    options: sanitizeOptions(payload.options || payload)
+  })
+
+  queueMicrotask(() => {
+    processJob(job).catch(error => {
+      logger.error(`[videoDecompose] Unexpected processing error for ${job.id}: ${error.message}`)
+      const record = getJobInternal(job.id)
+      if (record) {
+        failJob(job.id, error)
+      }
+    })
+  })
+
+  return getJob(job.id)
+}
+
+export function getVideoDecomposeTask(jobId) {
+  return getJob(jobId)
+}