Files
dj/huobao-source/backend/src/services/generation.ts
T

1005 lines
52 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* 统一生成任务服务 — 图片/视频生成共用 sys_task 表与同一条生命周期:
* 创建(processing) → 适配器构建请求 → 同步完成或异步轮询 → 下载落盘 → 回写业务表
*/
import { db, getInsertId, schema } from '../db/index.js'
import { and, desc, eq, gt, ne, or, isNull } from 'drizzle-orm'
import fs from 'node:fs'
import { getAbsolutePath } from '../utils/storage.js'
import { downloadVideo, safeTaskError } from './video-download.js'
import { prepareReferenceAudio, resolveReferenceAudioUrls } from './reference-audio.js'
import { getActiveConfig, getConfigById } from './ai.js'
import { parseWorkerRouting, type WorkerRouting } from './worker-routing.js'
import { isLocalQueuedTask, taskPollingProfile } from './local-task-tracking.js'
import { joinProviderUrl } from './adapters/url'
import { now } from '../utils/response.js'
import { downloadFile, fetchImageAsCompressedDataUrl, generateImageThumb, readImageAsCompressedDataUrl, readImageAsDataUrl, saveBase64Image } from '../utils/storage.js'
import { extractVideoPoster } from '../utils/video-poster.js'
import { ffmpeg } from '../utils/ffmpeg.js'
import { getImageAdapter, getVideoAdapter } from './adapters/registry'
import type { AIConfig } from './adapters/types'
import { logTaskError, logTaskPayload, logTaskProgress, logTaskStart, logTaskSuccess, logTaskWarn, redactUrl } from '../utils/task-logger.js'
import { continuityPrompt, extractContinuityFrame, resolveContinuity, sourceReadiness, validateContinuityModel, type ContinuityPlan } from './continuity.js'
import { englishSubmissionPrompt, usesEnglishVideoPrompt } from './english-video-prompt.js'
type TaskType = 'image' | 'video'
const activeTasks = new Set<number>()
const videoSubmissions = new Set<number>()
const cancellingTasks = new Set<number>()
function runBackground(id: number, job: () => Promise<void>) {
if (activeTasks.has(id)) return
activeTasks.add(id)
void job().catch(error => failTask(id, safeTaskError(error))).finally(() => activeTasks.delete(id))
}
const taskLabel = (type: TaskType) => (type === 'image' ? 'ImageTask' : 'VideoTask')
interface GenerateImageParams {
storyboardId?: number
dramaId?: number
sceneId?: number
characterId?: number
propId?: number
prompt: string
model?: string
size?: string
referenceImages?: string[]
frameType?: string
configId?: number
}
interface GenerateVideoParams {
gpu?: AIConfig['gpu']
replaceTaskId?: number
variant?: 'hd'
originalVideoUrl?: string
storyboardId?: number
dramaId?: number
prompt: string
model?: string
referenceMode?: string
imageUrl?: string
firstFrameUrl?: string
lastFrameUrl?: string
referenceImageUrls?: string[]
referenceVideoUrls?: string[]
referenceAudioUrls?: string[]
referenceFileUrl?: string
referenceLinkUrl?: string
generateAudio?: boolean
duration?: number
aspectRatio?: string
resolution?: string
seed?: number
promptExtend?: boolean
watermark?: boolean
configId?: number
forceNew?: boolean
}
export async function generateImage(params: GenerateImageParams): Promise<number> {
// 指定配置(集锁定)可能已停用/删除/厂商收敛,失效时回退到当前启用配置,避免生成被旧引用卡死
const config = params.configId
? (await getConfigById(params.configId)) ?? await getActiveConfig('image')
: await getActiveConfig('image')
if (!config) throw new Error('未配置图片模型,请先到「设置」页添加并启用 AI 服务')
const id = await createTask('image', config, {
storyboardId: params.storyboardId,
dramaId: params.dramaId,
sceneId: params.sceneId,
characterId: params.characterId,
propId: params.propId,
prompt: params.prompt,
model: params.model || config.model,
}, {
size: params.size || '1920x1080',
frameType: params.frameType,
referenceImages: params.referenceImages,
})
logTaskStart('ImageTask', 'enqueue', {
id,
provider: config.provider,
storyboardId: params.storyboardId,
sceneId: params.sceneId,
characterId: params.characterId,
frameType: params.frameType,
model: params.model || config.model,
})
logTaskPayload('ImageTask', 'enqueue params', {
id,
config: { provider: config.provider, model: config.model, baseUrl: config.baseUrl },
params,
})
return id
}
export async function generateVideo(params: GenerateVideoParams): Promise<number> {
const storyboardId = params.storyboardId
if (storyboardId && videoSubmissions.has(storyboardId)) throw new Error('该分镜正在提交任务,请勿重复点击')
if (storyboardId) videoSubmissions.add(storyboardId)
try {
if (params.gpu !== undefined && !['auto', 'gpu1', 'gpu2', 'gpu3'].includes(params.gpu)) throw new Error('请选择自动分配、GPU1、GPU2 或 GPU3')
if (params.replaceTaskId !== undefined && (!storyboardId || !Number.isSafeInteger(params.replaceTaskId) || params.replaceTaskId <= 0)) throw new Error('被替换的任务 ID 无效')
// 指定配置(集锁定)可能已停用/删除/厂商收敛,失效时回退到当前启用配置
const selectedConfig = params.configId
? await getConfigById(params.configId)
: await getActiveConfig('video')
const config = selectedConfig ? { ...selectedConfig, gpu: params.gpu ?? selectedConfig.gpu } : null
if (!config) throw new Error('未配置视频模型,请先到「设置」页添加并启用 AI 服务')
if (params.gpu !== undefined && !['localvideo', 'minimax'].includes(config.provider)) throw new Error('所选模型不支持指定本地显卡')
if (params.variant === 'hd' && (config.id !== params.configId || config.provider !== 'localvideo')) throw new Error('高清服务配置已停用或变更,请恢复 VDN-H3 配置')
params.referenceAudioUrls = await prepareReferenceAudio(params.referenceAudioUrls, config.provider)
const continuity = storyboardId && params.variant !== 'hd' ? (await resolveContinuity(storyboardId)).plan : null
if (continuity) validateContinuityModel(continuity, config, params.model)
if (continuity?.mode === 'first_frame' && params.referenceAudioUrls?.length) throw new Error('当前尾帧接续工作流不支持音色参考,请改为状态承接')
const previewParams = { ...params, prompt: continuity ? continuityPrompt(params.prompt, continuity) : params.prompt }
const english = usesEnglishVideoPrompt(params.model || config.model)
// Translate and validate BEFORE cancelling an old job or admitting a new one.
if (english) previewParams.prompt = await englishSubmissionPrompt(previewParams.prompt, storyboardId, params.dramaId)
if (continuity?.mode === 'first_frame') {
// A validation-only placeholder; never submitted as a generation input.
previewParams.firstFrameUrl = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aN1kAAAAASUVORK5CYII='
previewParams.imageUrl = undefined; previewParams.lastFrameUrl = undefined
previewParams.referenceImageUrls = []; previewParams.referenceVideoUrls = []
previewParams.referenceFileUrl = undefined; previewParams.referenceLinkUrl = undefined
}
// Validate the new request before touching the previous job.
getVideoAdapter(config.provider).buildGenerateRequest(config, { ...previewParams, id: 0,
referenceImageUrls: JSON.stringify(previewParams.referenceImageUrls || []),
referenceVideoUrls: JSON.stringify(previewParams.referenceVideoUrls || []),
referenceAudioUrls: JSON.stringify(previewParams.referenceAudioUrls || []) })
if (params.replaceTaskId && ['minimax', 'localvideo'].includes(config.provider)) {
const target = new URL(config.baseUrl)
if (target.hostname === '192.168.110.111' && ['18792', '18794'].includes(target.port)) {
// Preflight must see the same inline images as submission. A static/
// path is local to this computer and cannot be read by the GPU server.
const references = await prepareVideoReferences(previewParams, config.provider)
const validatedRequest = getVideoAdapter(config.provider).buildGenerateRequest(config, {
...previewParams, id: 0, ...references,
})
const response = await fetch(`${config.baseUrl.replace(/\/$/, '')}/v2/video_generation/validate`, {
method: 'POST', headers: { Authorization: `Bearer ${config.apiKey}`, 'Content-Type': 'application/json' },
body: JSON.stringify(validatedRequest.body), signal: AbortSignal.timeout(35_000) })
if (!response.ok) throw new Error(`新显卡未就绪,原任务保持运行:${safeTaskError(await response.text())}`)
}
}
if (storyboardId) {
const tasks = await db.select().from(schema.sysTask).where(and(eq(schema.sysTask.type, 'video'), eq(schema.sysTask.storyboardId, storyboardId)))
.orderBy(desc(schema.sysTask.id))
const latest = tasks[0]
if (params.replaceTaskId !== undefined && latest?.id !== params.replaceTaskId) throw new Error('任务已变化,请刷新后再操作;未取消任何其他任务')
if (tasks.some(t => t.status === 'processing' && t.id !== params.replaceTaskId)) throw new Error('该分镜已有运行中的任务,请等待结果')
if (latest?.status === 'processing') await cancelVideoForReplacement(latest)
if (latest?.status === 'failed' && params.forceNew !== true) throw new Error('请先恢复原任务;重新生成需确认可能再次计费')
}
const id = await createTask('video', config, {
storyboardId: params.storyboardId,
dramaId: params.dramaId,
prompt: english ? previewParams.prompt : params.prompt,
model: params.model || config.model,
}, {
continuity,
promptLanguage: english ? 'en' : 'original',
promptIncludesContinuity: english,
sourcePrompt: english ? params.prompt : undefined,
referenceMode: params.referenceMode || 'reference',
variant: params.variant,
originalVideoUrl: params.originalVideoUrl,
replacesTaskId: params.replaceTaskId,
imageUrl: params.imageUrl,
firstFrameUrl: params.firstFrameUrl,
lastFrameUrl: params.lastFrameUrl,
referenceImageUrls: params.referenceImageUrls,
referenceVideoUrls: params.referenceVideoUrls,
referenceAudioUrls: params.referenceAudioUrls,
referenceFileUrl: params.referenceFileUrl,
referenceLinkUrl: params.referenceLinkUrl,
generateAudio: params.generateAudio === false ? 0 : 1,
duration: params.duration,
aspectRatio: params.aspectRatio,
// 统一存为项目内部格式,各适配器再转换为官方大小写与枚举。
resolution: normalizeStoredVideoResolution(params.resolution),
seed: params.seed,
promptExtend: params.promptExtend,
watermark: params.watermark,
})
logTaskStart('VideoTask', 'enqueue', {
id,
provider: config.provider,
storyboardId: params.storyboardId,
dramaId: params.dramaId,
referenceMode: params.referenceMode || 'reference',
duration: params.duration || 5,
})
logTaskPayload('VideoTask', 'enqueue params', {
id,
config: { provider: config.provider, model: config.model, baseUrl: config.baseUrl },
params,
})
return id
} finally {
if (storyboardId) videoSubmissions.delete(storyboardId)
}
}
export async function cancelWaitingVideo(id: number) {
const result = await db.update(schema.sysTask).set({ status: 'failed', stage: 'cancelled', errorCode: 'user_cancelled',
errorMsg: '已取消等待前镜头的任务,未向显卡提交生成', updatedAt: now() })
.where(and(eq(schema.sysTask.id, id), eq(schema.sysTask.status, 'processing'), isNull(schema.sysTask.taskId),
or(eq(schema.sysTask.stage, 'waiting_predecessor'), eq(schema.sysTask.stage, 'blocked_predecessor')))).returning({ id: schema.sysTask.id })
if (!result.length) throw new Error('任务已经开始提交或结束,请刷新后再操作')
}
async function cancelVideoForReplacement(record: SysTaskRecord) {
const result = await cancelGenerationTask(record.id, 'replacement')
if (result.outcome === 'completed') throw new Error('原视频已经生成,正在保存;完成后可以重新生成')
if (result.outcome === 'pending') throw new Error('原任务仍在停止中,请稍后再点击;未提交新任务')
}
export function canCancelGenerationTask(record: SysTaskRecord): boolean {
if (record.status !== 'processing' || record.resultUrl || ['downloading', 'saving', 'transferring'].includes(record.stage || '')) return false
if (record.type === 'video' && !record.taskId && ['waiting_predecessor', 'blocked_predecessor'].includes(record.stage || '')) return true
return !!record.taskId && record.stage !== 'submitting'
&& (record.type === 'video' ? ['minimax', 'localvideo'].includes(record.provider || '') : record.type === 'image' && record.provider === 'openai')
&& isLocalQueuedTask({ baseUrl: record.configBaseUrl || '', provider: record.provider || '' }, record.taskId)
}
async function markTaskCancelled(id: number, reason = 'user') {
await db.update(schema.sysTask).set({ status: 'failed', stage: 'cancelled', errorCode: 'user_cancelled',
errorMsg: reason === 'replacement' ? '已取消原任务并请求重新生成,历史记录保留' : '任务已取消,历史记录和已有素材保留', updatedAt: now(), completedAt: now() })
.where(and(eq(schema.sysTask.id, id), eq(schema.sysTask.status, 'processing')))
}
export async function cancelGenerationTask(id: number, reason: 'user' | 'replacement' = 'user'): Promise<{ outcome: 'cancelled' | 'pending' | 'completed' | 'failed' }> {
if (!Number.isSafeInteger(id) || id <= 0) throw new Error('任务编号无效')
const record = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id)).get()
if (!record) throw new Error('任务不存在')
if (record.errorCode === 'user_cancelled') return { outcome: 'cancelled' }
if (record.status !== 'processing') throw new Error('任务已结束,请刷新列表')
if (cancellingTasks.has(id)) return { outcome: 'pending' }
if (!canCancelGenerationTask(record)) throw new Error('当前任务尚未返回编号、正在保存或不支持取消,请稍后刷新')
if (!record.taskId) { await cancelWaitingVideo(id); return { outcome: 'cancelled' } }
cancellingTasks.add(id)
try {
const config = await recoveryConfig(record)
const current = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id)).get()
if (!current || !canCancelGenerationTask(current)) throw new Error('任务状态已变化,请刷新后操作')
await db.update(schema.sysTask).set({ stage: 'cancelling', params: JSON.stringify({ ...parseTaskParams(current.params),
cancellation: { requestedAt: now(), reason } }), updatedAt: now() })
.where(and(eq(schema.sysTask.id, id), eq(schema.sysTask.status, 'processing')))
const headers = { Authorization: `Bearer ${config.apiKey}`, 'Content-Type': 'application/json' }
const request = async (cancel: boolean) => {
const job = encodeURIComponent(record.taskId!)
const path = record.type === 'image' ? `/images/task/${job}${cancel ? '/cancel' : ''}`
: cancel ? `/video_generation/${job}/cancel` : `/query/video_generation/${job}`
const response = await fetch(joinProviderUrl(config.baseUrl, record.type === 'image' ? '/v1' : '/v2', path), { method: cancel ? 'POST' : 'GET', headers,
...(cancel ? { body: '{}' } : {}), signal: AbortSignal.timeout(35_000) })
if (!response.ok) throw new Error('任务取消未确认,请稍后重试')
const result = await response.json() as any
const receipt = record.type === 'image' && !cancel ? { id: result.task_id,
status: result.cancelled ? 'cancelled' : result.status === 'completed' ? 'succeeded' : result.status } : result.task
if (receipt?.id !== record.taskId) throw new Error('取消回执任务编号不匹配')
return receipt.status as string
}
let status: string
const deadline = Date.now() + 45_000
try {
status = await request(true)
while (!['cancelled', 'failed', 'succeeded'].includes(status) && Date.now() < deadline) {
await new Promise(resolve => setTimeout(resolve, 1000))
status = await request(false)
}
} catch {
// The request may have reached the worker. Keep tracking the same ID;
// only an exact terminal receipt can declare it cancelled.
return { outcome: 'pending' }
}
if (status === 'cancelled') { await markTaskCancelled(id, reason); return { outcome: 'cancelled' } }
if (status === 'failed') { await failTask(id, '生成节点确认任务已失败', 'generation_failed'); return { outcome: 'failed' } }
if (status === 'succeeded') {
await db.update(schema.sysTask).set({ stage: 'polling', updatedAt: now() }).where(and(eq(schema.sysTask.id, id), eq(schema.sysTask.status, 'processing')))
return { outcome: 'completed' }
}
return { outcome: 'pending' }
} finally { cancellingTasks.delete(id) }
}
async function createTask(
type: TaskType,
config: AIConfig,
fields: {
storyboardId?: number
dramaId?: number
sceneId?: number
characterId?: number
propId?: number
prompt: string
model?: string | null
},
params: Record<string, unknown>,
): Promise<number> {
const ts = now()
const res = await db.insert(schema.sysTask).values({
type,
...fields,
provider: config.provider,
configId: config.id,
configBaseUrl: config.baseUrl,
stage: (params.continuity as ContinuityPlan | undefined)?.mode === 'first_frame' ? 'waiting_predecessor' : 'submitting',
params: JSON.stringify({ ...params, gpu: config.gpu || 'auto' }),
status: 'processing',
createdAt: ts,
updatedAt: ts,
})
const id = getInsertId(res)
runBackground(id, () => processTask(id, config))
return id
}
function parseTaskParams(raw: string | null | undefined): Record<string, any> {
if (!raw) return {}
try {
return JSON.parse(raw) || {}
} catch {
return {}
}
}
async function prepareContinuityTask(record: SysTaskRecord): Promise<boolean> {
const params = parseTaskParams(record.params)
const plan = params.continuity as ContinuityPlan | undefined
if (!plan || !record.storyboardId) return true
while (true) {
const current = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, record.id)).get()
if (!current || current.status !== 'processing') return false
const fresh = (await resolveContinuity(record.storyboardId)).plan
if (JSON.stringify(fresh) !== JSON.stringify(plan)) throw new Error('镜头衔接设置或前镜头结束状态已变化,请重新提交此镜头')
const source = plan.sourceId ? await sourceReadiness(plan.sourceId) : null
if (plan.mode === 'first_frame' && source?.state !== 'ready') {
await db.update(schema.sysTask).set({ stage: source?.state || 'waiting_predecessor', updatedAt: now() })
.where(and(eq(schema.sysTask.id, record.id), eq(schema.sysTask.status, 'processing')))
await new Promise(resolve => setTimeout(resolve, 2000))
continue
}
if (plan.mode === 'first_frame' && source) {
const frameUrl = await extractContinuityFrame(source.video, plan.offsetMs)
const after = await sourceReadiness(plan.sourceId!)
if (after.state !== 'ready' || after.video !== source.video || after.taskId !== source.taskId) continue
params.firstFrameUrl = frameUrl; params.imageUrl = undefined; params.lastFrameUrl = undefined
params.referenceImageUrls = []; params.referenceVideoUrls = []; params.referenceAudioUrls = []
params.referenceFileUrl = undefined; params.referenceLinkUrl = undefined
params.referenceMode = 'first_frame'
params.continuity = { ...plan, sourceVideo: source.video, sourceTaskId: source.taskId, frameUrl }
} else {
params.continuity = { ...plan, sourceVideo: source?.video || '', sourceTaskId: source?.taskId ?? null }
}
const prompt = params.promptIncludesContinuity ? record.prompt || '' : continuityPrompt(record.prompt || '', plan)
const claimed = await db.update(schema.sysTask).set({ params: JSON.stringify(params), prompt, stage: 'submitting', updatedAt: now() })
.where(and(eq(schema.sysTask.id, record.id), eq(schema.sysTask.status, 'processing'), isNull(schema.sysTask.taskId))).returning({ id: schema.sysTask.id })
return claimed.length > 0
}
}
async function processTask(id: number, config: AIConfig) {
try {
let [record] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id))
if (!record || record.status !== 'processing') return
if (record.type === 'video' && !await prepareContinuityTask(record)) return
;[record] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id))
const type = record.type as TaskType
const label = taskLabel(type)
const params = parseTaskParams(record.params)
logTaskProgress(label, 'build-request', {
id,
provider: config.provider,
storyboardId: record.storyboardId,
sceneId: record.sceneId,
characterId: record.characterId,
})
let url: string, method: string, headers: Record<string, string>, body: unknown
if (type === 'image') {
const adapter = getImageAdapter(config.provider)
const resolvedReferenceImages = await normalizeReferenceImages(params.referenceImages)
;({ url, method, headers, body } = adapter.buildGenerateRequest(config, {
id: record.id,
model: record.model,
prompt: record.prompt,
size: params.size,
frameType: params.frameType,
referenceImages: resolvedReferenceImages.length ? JSON.stringify(resolvedReferenceImages) : null,
}))
} else {
const adapter = getVideoAdapter(config.provider)
const references = await prepareVideoReferences(params, config.provider)
;({ url, method, headers, body } = adapter.buildGenerateRequest(config, {
id: record.id,
model: record.model,
prompt: record.prompt,
referenceMode: params.referenceMode,
...references,
referenceLinkUrl: params.referenceLinkUrl,
generateAudio: params.generateAudio,
duration: params.duration,
aspectRatio: params.aspectRatio,
resolution: params.resolution,
seed: params.seed,
promptExtend: params.promptExtend,
watermark: params.watermark,
}))
}
logTaskProgress(label, 'request', {
id,
provider: config.provider,
method,
url: redactUrl(url),
model: record.model,
})
const isMultipart = body instanceof FormData
logTaskPayload(label, 'request payload', {
id, method, url, headers,
// multipart 表单(如 OpenAI /v1/images/edits)无法 JSON 化,记录字段摘要
body: isMultipart ? `[multipart/form-data: ${[...(body as FormData).keys()].join(', ')}]` : body,
})
const beforeSend = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id)).get()
if (!beforeSend || beforeSend.status !== 'processing') return
if (params.continuity?.mode === 'first_frame') {
const source = await sourceReadiness(params.continuity.sourceId)
if (source.state !== 'ready' || source.video !== params.continuity.sourceVideo || source.taskId !== params.continuity.sourceTaskId) {
throw new Error('前镜头版本已变化,请重新提交此镜头;尚未发送到显卡')
}
}
const resp = await fetch(url, {
method,
headers,
body: isMultipart ? (body as FormData) : JSON.stringify(body),
signal: AbortSignal.timeout(600_000),
})
// Firemux 在响应头提供内部任务编号;即使 JSON 响应体中断也能查询原任务。
const gatewayTaskId = resp.headers.get('X-Firemux-Task-Id') || resp.headers.get('X-Huobao-Task-Id')
if (type === 'video' && gatewayTaskId) {
await markPolling(id, gatewayTaskId)
record.taskId = gatewayTaskId
}
if (!resp.ok) throw new Error(`API error ${resp.status}: ${await resp.text()}`)
const result = await resp.json() as any
logTaskPayload(label, 'response payload', { id, provider: config.provider, result })
if (type === 'image') {
const adapter = getImageAdapter(config.provider)
const { isAsync, taskId, imageUrl } = adapter.parseGenerateResponse(result)
if (!isAsync && imageUrl) {
logTaskProgress(label, 'sync-complete', { id, imageUrl })
await handleImageComplete(record, imageUrl)
return
}
if (!isAsync && !imageUrl) {
// 同步模式但无 URL(Gemini 等返回 base64)
const b64 = adapter.extractImageBase64(result)
if (b64) {
logTaskProgress(label, 'sync-base64-complete', { id, mimeType: b64.mimeType })
await handleImageCompleteBase64(record, b64.data, b64.mimeType)
return
}
throw new Error('No image URL or base64 data in response')
}
await markPolling(id, taskId)
await pollTask(record, config, taskId!)
return
}
const adapter = getVideoAdapter(config.provider)
const { isAsync, taskId, videoUrl, duration, routing } = adapter.parseGenerateResponse(result)
if (routing) await saveRouting(id, routing)
if (taskId) {
await markPolling(id, taskId)
record.taskId = taskId
}
if (!isAsync && videoUrl) {
logTaskProgress(label, 'sync-complete', { id, videoUrl })
await handleVideoComplete(record, videoUrl, duration ?? params.duration)
return
}
await markPolling(id, taskId)
await pollTask(record, config, taskId!)
} catch (err: any) {
const [current] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id))
const uncertain = current?.type === 'video' && !current.taskId && !current.resultUrl
&& (err instanceof TypeError || /timeout|abort|No task_id|API error 5/i.test(err.message))
await failTask(id, safeTaskError(err), uncertain ? 'submission_unknown' : undefined)
}
}
async function markPolling(id: number, taskId: string | undefined) {
await db.update(schema.sysTask)
.set({ taskId, stage: 'polling', status: 'processing', updatedAt: now() })
.where(eq(schema.sysTask.id, id))
logTaskProgress('SysTask', 'poll-start', { id, taskId })
}
async function saveRouting(id: number, routing: WorkerRouting) {
const checked = parseWorkerRouting(routing)
if (!checked) return
const [record] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id))
if (!record || record.status !== 'processing') return
await db.update(schema.sysTask).set({ params: JSON.stringify({ ...parseTaskParams(record.params), routing: checked }), updatedAt: now() })
.where(and(eq(schema.sysTask.id, id), eq(schema.sysTask.status, 'processing')))
}
async function failTask(id: number, message: string, code?: string) {
message = safeTaskError(message)
logTaskError('SysTask', 'failed', { id, error: message })
await db.update(schema.sysTask)
.set({ status: 'failed', errorMsg: safeTaskError(message), ...(code ? { errorCode: code } : {}), updatedAt: now() })
.where(and(eq(schema.sysTask.id, id), ne(schema.sysTask.status, 'completed'),
or(isNull(schema.sysTask.errorCode), ne(schema.sysTask.errorCode, 'user_cancelled'))))
}
type SysTaskRecord = typeof schema.sysTask.$inferSelect
async function pollTask(record: SysTaskRecord, config: AIConfig, taskId: string) {
const type = record.type as TaskType
const label = taskLabel(type)
const local = isLocalQueuedTask(config, taskId)
const profile = taskPollingProfile(type, local, parseTaskParams(record.params).variant === 'hd')
const adapter = type === 'image' ? getImageAdapter(config.provider) : getVideoAdapter(config.provider)
const startedAt = Date.now()
let delayMs = profile.intervalMs
let missingChecks = 0
for (let i = 0; i < profile.attempts; i++) {
if (profile.maxDurationMs && Date.now() - startedAt >= profile.maxDurationMs) {
await failTask(record.id, 'Timeout: Polling exceeded 10 minutes')
return
}
await new Promise(r => setTimeout(r, delayMs))
const [current] = await db.select({ status: schema.sysTask.status }).from(schema.sysTask).where(eq(schema.sysTask.id, record.id))
if (!current || current.status !== 'processing') return
try {
const { url, method, headers } = adapter.buildPollRequest(config, taskId)
logTaskProgress(label, 'poll-request', {
id: record.id,
taskId,
provider: config.provider,
method,
url: redactUrl(url),
attempt: i + 1,
})
const remainingMs = local ? 30_000 : profile.maxDurationMs
? Math.max(1_000, profile.maxDurationMs - (Date.now() - startedAt))
: 600_000
const resp = await fetch(url, {
method,
headers,
signal: AbortSignal.timeout(remainingMs),
})
if (!resp.ok) throw new Error(`Polling HTTP ${resp.status}`)
const result = await resp.json() as any
if (cancellingTasks.has(record.id)) continue
const [afterPoll] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, record.id))
if (!afterPoll || afterPoll.status !== 'processing') return
if (cancellingTasks.has(record.id)) continue
// 图片/视频 PollResponse 结构不同,这里统一按 any 取值后按 type 分支
const pollResp: any = adapter.parsePollResponse(result)
delayMs = profile.intervalMs
if (local && pollResp.status !== 'completed' && pollResp.status !== 'failed') {
missingChecks = pollResp.stage === 'missing' ? missingChecks + 1 : 0
if (missingChecks >= 3) {
await failTask(record.id, '显卡节点已找不到此任务,请核对节点重启记录后重新生成', 'upstream_missing')
return
}
const stage = parseTaskParams(afterPoll.params).cancellation ? 'cancelling' : pollResp.stage === 'missing' ? 'checking' : pollResp.stage || 'polling'
await db.update(schema.sysTask).set({ stage, updatedAt: now() })
.where(and(eq(schema.sysTask.id, record.id), eq(schema.sysTask.status, 'processing')))
}
if (type === 'video' && pollResp.routing) await saveRouting(record.id, pollResp.routing)
if (type === 'video' && local && pollResp.status === 'processing') {
const latest = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, record.id)).get()
if (latest?.status === 'processing') await db.update(schema.sysTask).set({
params: JSON.stringify({ ...parseTaskParams(latest.params), progress: pollResp.progress || null }),
}).where(and(eq(schema.sysTask.id, record.id), eq(schema.sysTask.status, 'processing')))
}
if (type === 'video' && pollResp.stage === 'transferring') {
await db.update(schema.sysTask).set({ stage: 'transferring', updatedAt: now() }).where(eq(schema.sysTask.id, record.id))
}
if (pollResp.status === 'completed') {
if (type === 'image') {
if (pollResp.imageUrl) {
logTaskSuccess(label, 'poll-complete', { id: record.id, taskId, imageUrl: pollResp.imageUrl })
if (await handleImageComplete(record, pollResp.imageUrl) === false) continue
return
}
if (adapter.provider === 'gemini') {
// Gemini 可能返回 base64
const b64 = (adapter as ReturnType<typeof getImageAdapter>).extractImageBase64(result)
if (b64) {
logTaskSuccess(label, 'poll-base64-complete', { id: record.id, taskId, mimeType: b64.mimeType })
await handleImageCompleteBase64(record, b64.data, b64.mimeType)
return
}
}
} else if (pollResp.videoUrl) {
logTaskSuccess(label, 'poll-complete', { id: record.id, taskId, videoUrl: pollResp.videoUrl })
if (await handleVideoComplete(record, pollResp.videoUrl, pollResp.duration) === false) continue
return
}
}
if (pollResp.status === 'failed') {
if (pollResp.cancelled) { await markTaskCancelled(record.id, parseTaskParams(afterPoll.params).cancellation?.reason); return }
// 上游明确失败(如内容审核拦截)属终态:立即落库,不重试不等待超时
const deliveryFailed = /video_transfer_failed/.test(pollResp.error || '')
if (deliveryFailed) await db.update(schema.sysTask).set({ stage: 'transferring' }).where(eq(schema.sysTask.id, record.id))
await failTask(record.id, pollResp.error || 'Generation failed', deliveryFailed ? 'delivery_failed' : 'generation_failed')
return
}
} catch (err: any) {
if (local) {
// A transient transport failure cannot cancel an accepted GPU job.
missingChecks = 0
delayMs = Math.min(60_000, Math.max(profile.intervalMs, delayMs * 2))
await db.update(schema.sysTask).set({ stage: 'reconnecting', updatedAt: now() })
.where(and(eq(schema.sysTask.id, record.id), eq(schema.sysTask.status, 'processing')))
logTaskWarn(label, 'poll-reconnect', { id: record.id, taskId, error: err.message })
continue
}
const exhausted = i === profile.attempts - 1
|| (profile.maxDurationMs != null && Date.now() - startedAt >= profile.maxDurationMs)
if (exhausted) {
await failTask(record.id, `Timeout: ${err.message}`)
return
}
logTaskWarn(label, 'poll-retry', { id: record.id, taskId, attempt: i + 1, error: err.message })
}
}
await failTask(record.id, 'Timeout: polling attempts exhausted')
}
async function handleImageComplete(record: SysTaskRecord, imageUrl: string) {
const current = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, record.id)).get()
if (!current || current.errorCode === 'user_cancelled') return
if (cancellingTasks.has(record.id)) return false
await db.update(schema.sysTask).set({ resultUrl: imageUrl, stage: 'downloading', updatedAt: now() })
.where(eq(schema.sysTask.id, record.id))
const localPath = await downloadFile(imageUrl, 'images')
// 列表页缩略图(前端按命名约定推导地址,失败不影响主流程)
await generateImageThumb(localPath)
await db.update(schema.sysTask)
.set({ resultUrl: imageUrl, localPath, status: 'completed', stage: 'completed', errorCode: null, errorMsg: null, completedAt: now(), updatedAt: now() })
.where(eq(schema.sysTask.id, record.id))
logTaskSuccess('ImageTask', 'downloaded', { id: record.id, provider: record.provider, localPath })
await writeBackImageAssets(record, localPath)
}
async function handleImageCompleteBase64(record: SysTaskRecord, base64Data: string, mimeType: string) {
const localPath = await saveBase64Image(base64Data, mimeType, 'images')
await generateImageThumb(localPath)
await db.update(schema.sysTask)
.set({ localPath, status: 'completed', stage: 'completed', errorCode: null, errorMsg: null, completedAt: now(), updatedAt: now() })
.where(eq(schema.sysTask.id, record.id))
logTaskSuccess('ImageTask', 'saved-base64', { id: record.id, provider: record.provider, mimeType, localPath })
await writeBackImageAssets(record, localPath)
}
// 图片完成后回写业务表:分镜(按 frameType)、角色、场景、道具
async function writeBackImageAssets(record: SysTaskRecord, localPath: string) {
const params = parseTaskParams(record.params)
// A late result is kept in task history, never substituted for a newer attempt.
const newer = await db.select().from(schema.sysTask).where(and(eq(schema.sysTask.type, 'image'), gt(schema.sysTask.id, record.id), or(
eq(schema.sysTask.characterId, record.characterId || -1), eq(schema.sysTask.sceneId, record.sceneId || -1),
eq(schema.sysTask.propId, record.propId || -1), eq(schema.sysTask.storyboardId, record.storyboardId || -1))))
if (newer.some(task => !record.storyboardId || parseTaskParams(task.params).frameType === params.frameType)) return
if (record.storyboardId) {
const sbUpdate: Record<string, any> = { updatedAt: now() }
if (params.frameType === 'first_frame') sbUpdate.firstFrameImage = localPath
else if (params.frameType === 'last_frame') sbUpdate.lastFrameImage = localPath
else sbUpdate.composedImage = localPath
await db.update(schema.storyboards).set(sbUpdate).where(eq(schema.storyboards.id, record.storyboardId))
}
if (record.characterId) {
await db.update(schema.characters).set({ imageUrl: localPath, updatedAt: now() }).where(eq(schema.characters.id, record.characterId))
}
if (record.sceneId) {
await db.update(schema.scenes).set({ imageUrl: localPath, status: 'completed', updatedAt: now() }).where(eq(schema.scenes.id, record.sceneId))
}
if (record.propId) {
await db.update(schema.props).set({ imageUrl: localPath, updatedAt: now() }).where(eq(schema.props.id, record.propId))
}
}
async function handleVideoComplete(record: SysTaskRecord, videoUrl: string, duration: number | null | undefined) {
const [current] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, record.id))
if (!current || current.errorCode === 'user_cancelled') return
if (cancellingTasks.has(record.id)) return false
// 先落库地址与实际时长;后续下载失败仍可恢复,且不重新提交生成。
const params: Record<string, unknown> = { ...parseTaskParams(current.params), resultDuration: duration }
await db.update(schema.sysTask).set({ resultUrl: videoUrl, params: JSON.stringify(params),
stage: 'downloading', status: 'processing', errorCode: null, errorMsg: null, updatedAt: now() })
.where(eq(schema.sysTask.id, record.id))
try {
const localPath = record.localPath && fs.existsSync(getAbsolutePath(record.localPath))
? record.localPath : await downloadVideo(videoUrl, record.id)
if (params.variant === 'hd') {
const readDimensions = () => new Promise<{ width?: number; height?: number }>((resolve, reject) => {
ffmpeg.ffprobe(getAbsolutePath(localPath), (error, meta) => {
if (error) return reject(error)
resolve(meta.streams.find(stream => stream.codec_type === 'video') || {})
})
})
let dimensions = await readDimensions()
const expected = params.resolution === '4K' ? [3840, 2160] : [2560, 1440]
if (params.aspectRatio === '9:16') expected.reverse()
// H3 aligns its latent dimensions to 32 pixels. Trim only that padding;
// never upscale a lower-resolution render and label it as native HD.
const aligned = expected.map(size => Math.ceil(size / 32) * 32)
if ((dimensions.width !== expected[0] || dimensions.height !== expected[1]) && dimensions.width === aligned[0] && dimensions.height === aligned[1]) {
const absolute = getAbsolutePath(localPath)
const cropped = `${absolute}.hd-crop.mp4`
try {
await new Promise<void>((resolve, reject) => ffmpeg(absolute)
.outputOptions(['-vf', `crop=${expected[0]}:${expected[1]}:0:0`, '-c:v', 'libx264', '-preset', 'fast', '-crf', '18', '-c:a', 'copy', '-movflags', '+faststart'])
.output(cropped).on('end', () => resolve()).on('error', reject).run())
await fs.promises.rename(cropped, absolute)
} finally { await fs.promises.rm(cropped, { force: true }) }
dimensions = await readDimensions()
}
if (dimensions.width !== expected[0] || dimensions.height !== expected[1]) throw new Error(`高清结果尺寸不匹配:需要 ${expected.join('×')},收到 ${dimensions.width}×${dimensions.height};原版保持不变`)
}
await db.update(schema.sysTask).set({ localPath, stage: 'saving', updatedAt: now() }).where(eq(schema.sysTask.id, record.id))
await extractVideoPoster(localPath)
// 完成状态与业务回写原子提交;恢复旧任务不能覆盖用户后来生成的视频。
db.transaction(tx => {
const newer = record.storyboardId ? tx.select({ id: schema.sysTask.id }).from(schema.sysTask)
.where(and(eq(schema.sysTask.storyboardId, record.storyboardId), eq(schema.sysTask.type, 'video'), gt(schema.sysTask.id, record.id))).get() : null
if (record.storyboardId && !newer && parseTaskParams(record.params).variant !== 'hd') tx.update(schema.storyboards)
.set({ videoUrl: localPath, duration: duration || undefined, updatedAt: now() })
.where(eq(schema.storyboards.id, record.storyboardId)).run()
tx.update(schema.sysTask).set({ localPath, status: 'completed', stage: 'completed', errorCode: null,
errorMsg: null, completedAt: now(), updatedAt: now() }).where(eq(schema.sysTask.id, record.id)).run()
})
} catch (error) {
await failTask(record.id, safeTaskError(error), 'delivery_failed')
}
}
async function recoveryConfig(record: SysTaskRecord): Promise<AIConfig> {
if (record.configId) {
const config = await getConfigById(record.configId)
if (config && config.provider === record.provider && config.baseUrl === record.configBaseUrl) return config
throw new Error('原生成服务配置已删除、停用或地址变更,请恢复原配置')
}
// 旧任务只在同厂商唯一配置时恢复,绝不任意换服务商查询。
const rows = (await db.select().from(schema.aiServiceConfigs)).filter(c => c.isActive && c.serviceType === record.type && c.provider === record.provider)
if (rows.length === 1) {
const config = await getConfigById(rows[0].id)
if (config) return config
}
throw new Error('历史任务无法确定原服务配置,请先核对配置')
}
export async function recoverVideoTask(id: number): Promise<void> {
const [record] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id))
if (!record || record.type !== 'video') throw new Error('视频任务不存在')
if (record.errorCode === 'user_cancelled') throw new Error('原任务已取消,请选择模型和显卡重新生成')
if (activeTasks.has(id) || record.status === 'completed') return
if (!record.resultUrl && !record.taskId) throw new Error('未保存上游任务编号,请先核对上游记录,勿重复生成')
if (record.errorCode === 'generation_failed') throw new Error('上游已确认生成失败,无法恢复原任务')
// 在任何异步配置读取前获取锁,重复点击不会启动多个下载。
activeTasks.add(id)
try {
const config = record.taskId && !record.resultUrl ? await recoveryConfig(record) : null
await db.update(schema.sysTask).set({ status: 'processing', errorMsg: null, errorCode: null,
stage: record.resultUrl ? 'downloading' : record.stage === 'transferring' || record.errorCode === 'delivery_failed' ? 'transferring' : 'polling', updatedAt: now() }).where(eq(schema.sysTask.id, id))
void (async () => {
if (record.resultUrl) {
await handleVideoComplete(record, record.resultUrl, parseTaskParams(record.params).resultDuration)
const [fresh] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id))
if (fresh?.status !== 'failed' || !record.taskId) return
// 签名链接可能过期:重新查询原任务拿新地址。
}
const originalConfig = config ?? await recoveryConfig(record)
// Firemux 的交付恢复是独立接口;只在其明确返回交付失败时调用。
if (record.provider === 'minimax' && (record.errorCode === 'delivery_failed' || record.stage === 'transferring') && !record.resultUrl) {
const req = getVideoAdapter('minimax').buildPollRequest(originalConfig, record.taskId!)
const resp = await fetch(`${req.url}/recover`, { method: 'POST', headers: req.headers, signal: AbortSignal.timeout(30_000) })
if (!resp.ok) throw new Error(`Video delivery recovery HTTP ${resp.status}`)
}
await markPolling(id, record.taskId!)
await pollTask(record, originalConfig, record.taskId!)
})().catch(error => failTask(id, safeTaskError(error), 'recovery_failed')).finally(() => activeTasks.delete(id))
} catch (error) {
activeTasks.delete(id)
throw error
}
}
export async function recoverGenerationTask(id: number): Promise<void> {
const [record] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id))
if (record?.type === 'video') return recoverVideoTask(id)
if (!record || record.type !== 'image') throw new Error('生成任务不存在')
if (['generation_failed', 'user_cancelled'].includes(record.errorCode || '')) throw new Error('原任务已结束,无法恢复')
if (activeTasks.has(id) || record.status === 'completed') return
if (!record.taskId) throw new Error('未保存上游任务编号,无法恢复')
activeTasks.add(id)
try {
const config = await recoveryConfig(record)
await db.update(schema.sysTask).set({ status: 'processing', errorMsg: null, errorCode: null, stage: 'polling', updatedAt: now() }).where(eq(schema.sysTask.id, id))
void pollTask(record, config, record.taskId).catch(error => failTask(id, safeTaskError(error), 'recovery_failed')).finally(() => activeTasks.delete(id))
} catch (error) { activeTasks.delete(id); throw error }
}
export async function resumeInterruptedTasks() {
const candidates = await db.select().from(schema.sysTask).where(or(eq(schema.sysTask.status, 'processing'), eq(schema.sysTask.status, 'failed'))).orderBy(desc(schema.sysTask.id))
const tasks = candidates.filter(task => task.status === 'processing' || (!task.errorCode && /^Timeout: (polling attempts exhausted|Polling exceeded 10 minutes)/.test(task.errorMsg || '')
&& isLocalQueuedTask({ provider: task.provider || '', baseUrl: task.configBaseUrl || '' }, task.taskId)))
for (const task of tasks) {
if (task.type === 'video' && !task.taskId && task.status === 'processing' && ['waiting_predecessor', 'blocked_predecessor'].includes(task.stage || '') && parseTaskParams(task.params).continuity?.mode === 'first_frame') {
try {
const config = await recoveryConfig(task)
runBackground(task.id, () => processTask(task.id, { ...config, gpu: parseTaskParams(task.params).gpu || config.gpu }))
} catch (error) { await failTask(task.id, safeTaskError(error), 'recovery_failed') }
continue
}
if ((task.type === 'video' && (task.taskId || task.resultUrl)) || (task.type === 'image' && isLocalQueuedTask({ provider: task.provider || '', baseUrl: task.configBaseUrl || '' }, task.taskId))) {
try { await recoverGenerationTask(task.id) } catch (error) { await failTask(task.id, safeTaskError(error), 'recovery_failed') }
} else {
await failTask(task.id, task.type === 'video' ? '服务中断,提交结果待确认,请先核对上游记录' : '服务重启,生成任务中断,请重试',
task.type === 'video' ? 'submission_unknown' : 'interrupted')
}
}
}
// ─── 参考素材归一化 ───────────────────────────────────────────────
async function normalizeReferenceImages(refs: string[] | null | undefined): Promise<string[]> {
if (!Array.isArray(refs) || !refs.length) return []
const deduped = Array.from(
new Set(
refs
.map((item) => String(item || '').trim())
.filter(Boolean),
),
)
const normalized = await Promise.all(deduped.map(async (value) => {
if (value.startsWith('data:image/')) return value
if (value.startsWith('static/') || value.startsWith('/static/')) {
const localPath = value.startsWith('/static/') ? value.slice(1) : value
try {
return await readImageAsCompressedDataUrl(localPath, {
maxWidth: 768,
maxHeight: 768,
quality: 68,
})
} catch (err) {
logTaskWarn('ImageTask', 'reference-read-failed', { path: localPath, error: (err as Error).message })
throw new Error('参考图读取失败,请重新上传后再生成')
}
}
// 远程 URL:下载压缩为 data URL,保证 multipart 上传(OpenAI edits)/ inline_data(Gemini)都可用
if (/^https?:\/\//.test(value)) {
try {
return await fetchImageAsCompressedDataUrl(value, {
maxWidth: 768,
maxHeight: 768,
quality: 68,
})
} catch (err) {
logTaskWarn('ImageTask', 'reference-fetch-failed', { url: value, error: (err as Error).message })
throw new Error('参考图读取失败,请重新上传后再生成')
}
}
throw new Error('参考图地址无效,请重新上传后再生成')
}))
if (normalized.length > 6) throw new Error('参考图最多 6 张')
return normalized
}
async function prepareVideoReferences(params: Pick<GenerateVideoParams, 'imageUrl' | 'firstFrameUrl' | 'lastFrameUrl' |
'referenceImageUrls' | 'referenceVideoUrls' | 'referenceAudioUrls' | 'referenceFileUrl'>, provider: string) {
const imageUrl = await normalizeVideoReferenceUrl(params.imageUrl)
const firstFrameUrl = await normalizeVideoReferenceUrl(params.firstFrameUrl)
const lastFrameUrl = await normalizeVideoReferenceUrl(params.lastFrameUrl)
const images = await normalizeVideoReferenceUrls(params.referenceImageUrls)
const videos = resolvePublicMediaUrls(params.referenceVideoUrls, 'video')
const audios = await resolveReferenceAudioUrls(params.referenceAudioUrls, provider)
return { imageUrl, firstFrameUrl, lastFrameUrl,
referenceImageUrls: images.length ? JSON.stringify(images) : null,
referenceVideoUrls: videos.length ? JSON.stringify(videos) : null,
referenceAudioUrls: audios.length ? JSON.stringify(audios) : null,
referenceFileUrl: resolvePublicMediaUrl(params.referenceFileUrl, 'file') }
}
async function normalizeVideoReferenceUrl(value: string | null | undefined): Promise<string | null> {
const raw = String(value || '').trim()
if (!raw) return null
if (raw.startsWith('data:image/')) return raw
if (raw.startsWith('static/') || raw.startsWith('/static/')) {
const localPath = raw.startsWith('/static/') ? raw.slice(1) : raw
try {
// 视频参考图直接编码原文件,保留原始尺寸、格式、透明通道和画质。
return readImageAsDataUrl(localPath)
} catch (err) {
logTaskWarn('VideoTask', 'reference-read-failed', { path: localPath, error: (err as Error).message })
throw new Error('参考图读取失败,请重新上传后再生成')
}
}
return raw
}
async function normalizeVideoReferenceUrls(refs: string[] | null | undefined): Promise<string[]> {
if (!Array.isArray(refs) || !refs.length) return []
const normalized = await Promise.all(
Array.from(new Set(refs.map((item) => String(item || '').trim()).filter(Boolean))).map((item) => normalizeVideoReferenceUrl(item)),
)
return normalized.filter((item): item is string => !!item)
}
/**
* 将参考视频/音频解析为 Seedance API 可访问的 URL。
* http(s)/dataURL 直通;本地 static 路径需要 PUBLIC_BASE_URL 拼成公网地址,
* 未配置时抛出可操作的中文错误(落入 catch 写入 error_msg 供前端展示)。
*/
function resolvePublicMediaUrl(value: string | null | undefined, kind: 'video' | 'audio' | 'file'): string | null {
const raw = String(value || '').trim()
if (!raw) return null
if (raw.startsWith('http://') || raw.startsWith('https://') || raw.startsWith('data:')) return raw
if (raw.startsWith('static/') || raw.startsWith('/static/')) {
const base = (process.env.PUBLIC_BASE_URL || '').trim().replace(/\/+$/, '')
if (!base) {
const label = kind === 'video' ? '视频' : kind === 'audio' ? '音频' : '文件'
throw new Error(
`参考${label}为本地路径 ${raw},但后端未配置 PUBLIC_BASE_URL,上游视频生成 API 无法访问内网地址。` +
`请在 backend/.env 配置 PUBLIC_BASE_URL(如 https://your-domain.com)后重试,或改用公网 URL。`,
)
}
const p = raw.startsWith('/') ? raw : `/${raw}`
return `${base}${p}`
}
return raw
}
function resolvePublicMediaUrls(refs: string[] | null | undefined, kind: 'video' | 'audio'): string[] {
if (!Array.isArray(refs) || !refs.length) return []
const items = Array.from(new Set(refs.map((item) => String(item || '').trim()).filter(Boolean)))
return items.map((item) => resolvePublicMediaUrl(item, kind)).filter((item): item is string => !!item)
}
function normalizeStoredVideoResolution(resolution: string | null | undefined): string | undefined {
const value = String(resolution || '').trim().toLowerCase()
if (value === '480p' || value === '720p' || value === '1080p') return value
if (value === '2k') return '2K'
if (value === '4k') return '4K'
return undefined
}