530 lines
18 KiB
JavaScript
530 lines
18 KiB
JavaScript
#!/usr/bin/env node
|
||
import { spawnSync } from 'node:child_process';
|
||
import { createWriteStream, readFileSync } from 'node:fs';
|
||
import fs from 'node:fs/promises';
|
||
import path from 'node:path';
|
||
import { Readable } from 'node:stream';
|
||
import { fileURLToPath } from 'node:url';
|
||
|
||
const SEGMENT_SECONDS = 15;
|
||
const SEGMENT_COUNT = 4;
|
||
const TARGET_SECONDS = SEGMENT_SECONDS * SEGMENT_COUNT;
|
||
const TEMPLATE_IDS = [
|
||
'video_turntable',
|
||
'video_unboxing',
|
||
'video_touch_detail',
|
||
'video_story_intro',
|
||
'video_factory_preview',
|
||
];
|
||
const PART_CUES = [
|
||
'第 1 段：建立镜头，先稳定展示 45cm 高、正面约 32cm 宽的大号糯糯猪整体体量、圆胖坐姿和核心识别点。',
|
||
'第 2 段：继续同一只玩偶，推进到侧面约 28cm 深、背面约 33cm 宽、耳朵、鼻子、吊牌和毛绒细节，不改变外观。',
|
||
'第 3 段：保持 45cm 大号比例，加入成人双手抱持、前臂托住或胸前怀抱，让玩偶显得可拥抱且超过 40cm。',
|
||
'第 4 段：回到产品展示收束，补充包装、材料、生产或温暖陪伴镜头，包装/手部比例必须支持 45cm 成品尺寸。',
|
||
];
|
||
|
||
const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
|
||
const args = parseArgs(process.argv.slice(2));
|
||
const command = args._[0] || 'run';
|
||
const sessionId = args.session || args._[1];
|
||
if (!sessionId) fail('Usage: node scripts/seedance-60s-compose.mjs run --session <sessionId> [--env deploy/.env.production]');
|
||
const runLabel = safe(args['run-label'] || 'seedance60');
|
||
const freshRun = Boolean(args.fresh);
|
||
const selectedTemplateIds = String(args.templates || '')
|
||
.split(',')
|
||
.map(item => item.trim())
|
||
.filter(Boolean);
|
||
const activeTemplateIds = selectedTemplateIds.length ? selectedTemplateIds : TEMPLATE_IDS;
|
||
|
||
const env = {
|
||
...readEnvFile(path.join(root, args.env || '.env.local')),
|
||
...process.env,
|
||
};
|
||
const apiKey = env.SEEDANCE_API_KEY;
|
||
if (!apiKey) fail('SEEDANCE_API_KEY missing');
|
||
const apiBase = env.SEEDANCE_API_BASE || 'https://ark.cn-beijing.volces.com/api/v3';
|
||
const model = env.SEEDANCE_MODEL || 'doubao-seedance-2-0-260128';
|
||
const publicAppUrl = env.PUBLIC_APP_URL || env.NEXT_PUBLIC_APP_URL || 'https://ai-toy.kang-kang.com';
|
||
const sessionPath = path.join(root, 'data', 'sessions', `${sessionId}.json`);
|
||
const trackerDir = path.join(root, 'data', 'video-segments');
|
||
const trackerPath = path.join(trackerDir, `${sessionId}-${runLabel}.json`);
|
||
const videosDir = path.join(root, 'data', 'videos');
|
||
const segmentDir = path.join(videosDir, 'segments', sessionId, runLabel);
|
||
|
||
await fs.mkdir(trackerDir, { recursive: true });
|
||
await fs.mkdir(segmentDir, { recursive: true });
|
||
|
||
if (command === 'submit') {
|
||
const tracker = await ensureTracker();
|
||
if (freshRun) await updateAllProgress(tracker);
|
||
await submitMissingSegments(tracker);
|
||
await saveTracker(tracker);
|
||
printSummary(tracker);
|
||
} else if (command === 'poll') {
|
||
const tracker = await ensureTracker();
|
||
await pollAndCompose(tracker, { once: true });
|
||
await saveTracker(tracker);
|
||
printSummary(tracker);
|
||
} else if (command === 'run') {
|
||
const tracker = await ensureTracker();
|
||
if (freshRun) await updateAllProgress(tracker);
|
||
await submitMissingSegments(tracker);
|
||
await saveTracker(tracker);
|
||
await pollAndCompose(tracker, { once: Boolean(args.once) });
|
||
await saveTracker(tracker);
|
||
printSummary(tracker);
|
||
} else {
|
||
fail(`Unknown command: ${command}`);
|
||
}
|
||
|
||
function parseArgs(argv) {
|
||
const parsed = { _: [] };
|
||
for (let i = 0; i < argv.length; i += 1) {
|
||
const item = argv[i];
|
||
if (!item.startsWith('--')) {
|
||
parsed._.push(item);
|
||
continue;
|
||
}
|
||
const key = item.slice(2);
|
||
const next = argv[i + 1];
|
||
if (!next || next.startsWith('--')) {
|
||
parsed[key] = true;
|
||
} else {
|
||
parsed[key] = next;
|
||
i += 1;
|
||
}
|
||
}
|
||
return parsed;
|
||
}
|
||
|
||
function readEnvFile(filePath) {
|
||
try {
|
||
const text = readFileSync(filePath, 'utf8');
|
||
const out = {};
|
||
for (const line of text.split(/\r?\n/)) {
|
||
const trimmed = line.trim();
|
||
if (!trimmed || trimmed.startsWith('#')) continue;
|
||
const idx = trimmed.indexOf('=');
|
||
if (idx < 0) continue;
|
||
out[trimmed.slice(0, idx)] = trimmed.slice(idx + 1).replace(/^["']|["']$/g, '');
|
||
}
|
||
return out;
|
||
} catch {
|
||
return {};
|
||
}
|
||
}
|
||
|
||
async function ensureTracker() {
|
||
const session = await readSession();
|
||
let tracker = await readTracker();
|
||
if (!tracker) {
|
||
tracker = {
|
||
sessionId,
|
||
model,
|
||
provider: 'seedance',
|
||
targetSeconds: TARGET_SECONDS,
|
||
segmentSeconds: SEGMENT_SECONDS,
|
||
createdAt: Date.now(),
|
||
updatedAt: Date.now(),
|
||
templates: {},
|
||
};
|
||
}
|
||
|
||
const anchor = findAnchor(session);
|
||
const referenceUrls = findVideoReferenceUrls(session, anchor);
|
||
for (const templateId of activeTemplateIds) {
|
||
const task = (session.videoTasks || []).find(item => item.templateId === templateId);
|
||
if (!task) continue;
|
||
const entry = tracker.templates[templateId] || {
|
||
templateId,
|
||
title: task.title,
|
||
ratio: task.ratio || '16:9',
|
||
prompt: task.prompt,
|
||
anchorImageUrl: anchor,
|
||
referenceUrls,
|
||
finalVideoUrl: undefined,
|
||
segments: [],
|
||
};
|
||
entry.title = entry.title || task.title;
|
||
entry.ratio = entry.ratio || task.ratio || '16:9';
|
||
entry.prompt = entry.prompt || task.prompt;
|
||
entry.anchorImageUrl = entry.anchorImageUrl || anchor;
|
||
entry.referenceUrls = entry.referenceUrls?.length ? entry.referenceUrls : referenceUrls;
|
||
if (!freshRun && task.taskId && !entry.segments.some(segment => segment.part === 1)) {
|
||
entry.segments.push({
|
||
part: 1,
|
||
taskId: task.taskId,
|
||
status: task.status || 'submitted',
|
||
source: 'existing_session_task',
|
||
submittedAt: task.submittedAt || Date.now(),
|
||
});
|
||
}
|
||
for (let part = 1; part <= SEGMENT_COUNT; part += 1) {
|
||
if (!entry.segments.some(segment => segment.part === part)) {
|
||
entry.segments.push({ part, status: 'pending' });
|
||
}
|
||
}
|
||
entry.segments.sort((a, b) => a.part - b.part);
|
||
tracker.templates[templateId] = entry;
|
||
}
|
||
tracker.updatedAt = Date.now();
|
||
return tracker;
|
||
}
|
||
|
||
async function submitMissingSegments(tracker) {
|
||
for (const entry of Object.values(tracker.templates)) {
|
||
for (const segment of entry.segments) {
|
||
if (segment.taskId || segment.status === 'succeeded') continue;
|
||
const response = await submitSegment(entry, segment.part);
|
||
segment.taskId = response.taskId;
|
||
segment.status = response.status;
|
||
segment.raw = response.raw;
|
||
segment.submittedAt = Date.now();
|
||
console.log(JSON.stringify({
|
||
action: 'submitted',
|
||
templateId: entry.templateId,
|
||
part: segment.part,
|
||
taskId: segment.taskId,
|
||
status: segment.status,
|
||
}));
|
||
await updateSessionProgress(entry);
|
||
await saveTracker(tracker);
|
||
}
|
||
}
|
||
}
|
||
|
||
async function submitSegment(entry, part) {
|
||
const body = {
|
||
model,
|
||
content: [
|
||
{ type: 'text', text: segmentPrompt(entry.prompt, part) },
|
||
...entry.referenceUrls.map(url => ({
|
||
type: 'image_url',
|
||
image_url: { url: publicUrl(url) },
|
||
role: 'reference_image',
|
||
})),
|
||
],
|
||
generate_audio: true,
|
||
ratio: entry.ratio || '16:9',
|
||
duration: SEGMENT_SECONDS,
|
||
watermark: false,
|
||
};
|
||
const res = await fetch(`${apiBase}/contents/generations/tasks`, {
|
||
method: 'POST',
|
||
headers: {
|
||
'content-type': 'application/json',
|
||
authorization: `Bearer ${apiKey}`,
|
||
},
|
||
body: JSON.stringify(body),
|
||
});
|
||
const rawText = await res.text();
|
||
if (!res.ok) throw new Error(`Seedance submit ${res.status}: ${rawText}`);
|
||
const raw = JSON.parse(rawText);
|
||
return {
|
||
taskId: raw.task_id || raw.id,
|
||
status: normalizeStatus(raw.status),
|
||
raw,
|
||
};
|
||
}
|
||
|
||
async function pollAndCompose(tracker, opts) {
|
||
const maxWaitMs = Number(args['max-wait-minutes'] || 90) * 60 * 1000;
|
||
const pollMs = Number(args['poll-seconds'] || 45) * 1000;
|
||
const started = Date.now();
|
||
while (true) {
|
||
let changed = false;
|
||
for (const entry of Object.values(tracker.templates)) {
|
||
let entryChanged = false;
|
||
for (const segment of entry.segments) {
|
||
if (!segment.taskId || segment.status === 'succeeded' || segment.status === 'failed') continue;
|
||
const response = await getTask(segment.taskId);
|
||
segment.status = response.status;
|
||
segment.raw = response.raw;
|
||
segment.updatedAt = Date.now();
|
||
changed = true;
|
||
entryChanged = true;
|
||
if (response.videoUrl) {
|
||
segment.remoteVideoUrl = response.videoUrl;
|
||
}
|
||
if (response.status === 'succeeded') {
|
||
segment.filePath = await downloadVideo(sessionId, entry.templateId, segment.part, segment.taskId, response.videoUrl);
|
||
console.log(JSON.stringify({
|
||
action: 'downloaded',
|
||
templateId: entry.templateId,
|
||
part: segment.part,
|
||
taskId: segment.taskId,
|
||
}));
|
||
}
|
||
}
|
||
if (!entry.finalVideoUrl && entry.segments.every(segment => segment.status === 'succeeded' && segment.filePath)) {
|
||
entry.finalVideoUrl = await composeTemplate(entry);
|
||
await updateFinalTask(entry);
|
||
changed = true;
|
||
entryChanged = true;
|
||
console.log(JSON.stringify({
|
||
action: 'composed',
|
||
templateId: entry.templateId,
|
||
videoUrl: entry.finalVideoUrl,
|
||
}));
|
||
}
|
||
if (entryChanged && !entry.finalVideoUrl) {
|
||
await updateSessionProgress(entry);
|
||
}
|
||
}
|
||
tracker.updatedAt = Date.now();
|
||
if (changed) await saveTracker(tracker);
|
||
if (allDone(tracker) || opts.once) break;
|
||
if (Date.now() - started > maxWaitMs) fail(`Timed out waiting for Seedance tasks after ${Math.round(maxWaitMs / 60000)} minutes`);
|
||
await sleep(pollMs);
|
||
}
|
||
}
|
||
|
||
async function getTask(taskId) {
|
||
const res = await fetch(`${apiBase}/contents/generations/tasks/${encodeURIComponent(taskId)}`, {
|
||
headers: { authorization: `Bearer ${apiKey}` },
|
||
});
|
||
const rawText = await res.text();
|
||
if (!res.ok) throw new Error(`Seedance status ${res.status}: ${rawText}`);
|
||
const raw = JSON.parse(rawText);
|
||
return {
|
||
status: normalizeStatus(raw.status),
|
||
videoUrl: raw.video_url || raw.output?.video_url || raw.output?.url || raw.content?.video_url || raw.content?.url,
|
||
raw,
|
||
};
|
||
}
|
||
|
||
async function downloadVideo(sessionIdValue, templateId, part, taskId, url) {
|
||
if (!url) throw new Error(`missing video URL for ${templateId} part ${part}`);
|
||
const res = await fetch(url);
|
||
if (!res.ok) throw new Error(`download ${res.status} for ${templateId} part ${part}`);
|
||
const type = res.headers.get('content-type') || 'video/mp4';
|
||
const ext = type.includes('webm') ? 'webm' : 'mp4';
|
||
const filename = `${safe(sessionIdValue)}_${safe(templateId)}_part${part}_${safe(taskId)}.${ext}`;
|
||
const filePath = path.join(segmentDir, filename);
|
||
await streamToFile(res.body, filePath);
|
||
return filePath;
|
||
}
|
||
|
||
async function composeTemplate(entry) {
|
||
const outputName = `${safe(sessionId)}_${safe(entry.templateId)}_${runLabel}_60s.mp4`;
|
||
const outputPath = path.join(videosDir, outputName);
|
||
const listPath = path.join(segmentDir, `${safe(entry.templateId)}_concat.txt`);
|
||
const list = entry.segments
|
||
.sort((a, b) => a.part - b.part)
|
||
.map(segment => `file '${String(segment.filePath).replace(/'/g, "'\\''")}'`)
|
||
.join('\n');
|
||
await fs.writeFile(listPath, `${list}\n`);
|
||
|
||
let result = spawnSync('ffmpeg', ['-y', '-f', 'concat', '-safe', '0', '-i', listPath, '-c', 'copy', outputPath], { encoding: 'utf8' });
|
||
if (result.status !== 0) {
|
||
result = spawnSync('ffmpeg', ['-y', '-f', 'concat', '-safe', '0', '-i', listPath, '-c:v', 'libx264', '-c:a', 'aac', '-movflags', '+faststart', outputPath], { encoding: 'utf8' });
|
||
}
|
||
if (result.status !== 0) {
|
||
throw new Error(`ffmpeg failed for ${entry.templateId}: ${result.stderr || result.stdout}`);
|
||
}
|
||
return `/api/video-file/${outputName}`;
|
||
}
|
||
|
||
async function updateFinalTask(entry) {
|
||
const session = await readSession();
|
||
const index = (session.videoTasks || []).findIndex(task => task.templateId === entry.templateId);
|
||
if (index < 0) throw new Error(`session video task missing: ${entry.templateId}`);
|
||
const now = Date.now();
|
||
const current = session.videoTasks[index];
|
||
session.videoTasks[index] = {
|
||
...current,
|
||
provider: 'seedance',
|
||
model,
|
||
status: 'succeeded',
|
||
videoUrl: entry.finalVideoUrl,
|
||
duration: TARGET_SECONDS,
|
||
updatedAt: now,
|
||
raw: {
|
||
...(typeof current.raw === 'object' && current.raw ? current.raw : {}),
|
||
seedance60: {
|
||
runLabel,
|
||
targetSeconds: TARGET_SECONDS,
|
||
segmentSeconds: SEGMENT_SECONDS,
|
||
composedAt: now,
|
||
segments: entry.segments.map(segment => ({
|
||
part: segment.part,
|
||
taskId: segment.taskId,
|
||
status: segment.status,
|
||
remoteVideoUrl: segment.remoteVideoUrl,
|
||
})),
|
||
},
|
||
},
|
||
};
|
||
await fs.writeFile(sessionPath, `${JSON.stringify(session, null, 2)}\n`);
|
||
}
|
||
|
||
async function updateAllProgress(tracker) {
|
||
for (const entry of Object.values(tracker.templates)) {
|
||
await updateSessionProgress(entry);
|
||
}
|
||
}
|
||
|
||
async function updateSessionProgress(entry) {
|
||
const session = await readSession();
|
||
const index = (session.videoTasks || []).findIndex(task => task.templateId === entry.templateId);
|
||
if (index < 0) return;
|
||
const now = Date.now();
|
||
const current = session.videoTasks[index];
|
||
const firstTaskId = entry.segments.find(segment => segment.taskId)?.taskId;
|
||
session.videoTasks[index] = {
|
||
...current,
|
||
provider: 'seedance',
|
||
model,
|
||
taskId: firstTaskId,
|
||
status: taskStatus(entry),
|
||
videoUrl: entry.finalVideoUrl,
|
||
duration: TARGET_SECONDS,
|
||
updatedAt: now,
|
||
raw: {
|
||
...(typeof current.raw === 'object' && current.raw ? current.raw : {}),
|
||
seedance60: {
|
||
runLabel,
|
||
targetSeconds: TARGET_SECONDS,
|
||
segmentSeconds: SEGMENT_SECONDS,
|
||
updatedAt: now,
|
||
segments: entry.segments.map(segment => ({
|
||
part: segment.part,
|
||
taskId: segment.taskId,
|
||
status: segment.status,
|
||
remoteVideoUrl: segment.remoteVideoUrl,
|
||
})),
|
||
},
|
||
},
|
||
};
|
||
await fs.writeFile(sessionPath, `${JSON.stringify(session, null, 2)}\n`);
|
||
}
|
||
|
||
function taskStatus(entry) {
|
||
if (entry.finalVideoUrl) return 'succeeded';
|
||
if (entry.segments.some(segment => segment.status === 'failed')) return 'failed';
|
||
if (entry.segments.some(segment => segment.status === 'processing')) return 'processing';
|
||
if (entry.segments.some(segment => segment.taskId)) return 'submitted';
|
||
return 'processing';
|
||
}
|
||
|
||
function segmentPrompt(prompt, part) {
|
||
return [
|
||
prompt.trim(),
|
||
'',
|
||
`这是 Seedance 分段生成的第 ${part}/${SEGMENT_COUNT} 段，每段 ${SEGMENT_SECONDS} 秒，最终会拼成 ${TARGET_SECONDS} 秒完整视频。`,
|
||
PART_CUES[part - 1],
|
||
'硬性尺寸约束：主角始终是“有你家族 · 糯糯猪”智能陪伴毛绒娃娃，高度约 45cm，正面宽约 32cm，侧深约 28cm，背面宽约 33cm。',
|
||
'必须明显是 40cm 以上的大尺寸抱抱玩偶：优先用成人双手、前臂、胸前怀抱、包装盒、椅子或床品证明比例；不能像掌心小玩偶、桌面摆件、挂件或钥匙扣。',
|
||
'参考图里的中文和数字只用于理解尺寸比例；成片画面中不要生成任何数字、厘米文字、箭头尺寸标注或文字海报，避免出现错误读数。',
|
||
'保持浅粉长绒、圆胖坐姿、黑亮眼睛、粉色猪鼻、下垂耳朵、金色挂绳和爱心吊牌，不要变成小挂件、桌面小摆件或其它动物。',
|
||
].join('\n');
|
||
}
|
||
|
||
function normalizeStatus(status) {
|
||
if (status === 'succeeded' || status === 'success' || status === 'completed') return 'succeeded';
|
||
if (status === 'failed' || status === 'error') return 'failed';
|
||
if (status === 'processing' || status === 'running' || status === 'in_progress') return 'processing';
|
||
return 'submitted';
|
||
}
|
||
|
||
function publicUrl(url) {
|
||
if (/^https?:\/\//i.test(url)) return url;
|
||
return new URL(url, publicAppUrl).toString();
|
||
}
|
||
|
||
function findAnchor(session) {
|
||
const packs = session.packs || [];
|
||
const preferred = [
|
||
['marketing', 'mkt_white_front'],
|
||
['patent', 'patent_front'],
|
||
];
|
||
for (const [kind, templateId] of preferred) {
|
||
const asset = packs.find(pack => pack.kind === kind)?.assets?.find(item => item.templateId === templateId);
|
||
if (asset?.url) return asset.url;
|
||
}
|
||
const selected = (session.images || []).find(image => image.status === 'selected') || session.images?.[0];
|
||
if (selected?.url) return selected.url;
|
||
fail('No anchor image found');
|
||
}
|
||
|
||
function findVideoReferenceUrls(session, fallbackUrl) {
|
||
const preferredTemplateIds = [
|
||
'prod_dimension_overall',
|
||
'mkt_white_front',
|
||
'mkt_white_back',
|
||
];
|
||
const urls = [];
|
||
for (const templateId of preferredTemplateIds) {
|
||
const url = findAssetUrl(session, templateId);
|
||
if (url) urls.push(url);
|
||
}
|
||
if (fallbackUrl) urls.push(fallbackUrl);
|
||
return [...new Set(urls)];
|
||
}
|
||
|
||
function findAssetUrl(session, templateId) {
|
||
for (const pack of session.packs || []) {
|
||
const asset = pack.assets?.find(item => item.templateId === templateId);
|
||
if (asset?.url) return asset.url;
|
||
}
|
||
return undefined;
|
||
}
|
||
|
||
async function readSession() {
|
||
return JSON.parse(await fs.readFile(sessionPath, 'utf8'));
|
||
}
|
||
|
||
async function readTracker() {
|
||
try {
|
||
return JSON.parse(await fs.readFile(trackerPath, 'utf8'));
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
async function saveTracker(tracker) {
|
||
await fs.writeFile(trackerPath, `${JSON.stringify(tracker, null, 2)}\n`);
|
||
}
|
||
|
||
function allDone(tracker) {
|
||
return Object.values(tracker.templates).every(entry => entry.finalVideoUrl);
|
||
}
|
||
|
||
async function streamToFile(body, filePath) {
|
||
if (!body) throw new Error('response body missing');
|
||
await fs.mkdir(path.dirname(filePath), { recursive: true });
|
||
await new Promise((resolve, reject) => {
|
||
const stream = createWriteStream(filePath);
|
||
Readable.fromWeb(body).pipe(stream);
|
||
stream.on('finish', resolve);
|
||
stream.on('error', reject);
|
||
});
|
||
}
|
||
|
||
function printSummary(tracker) {
|
||
const summary = Object.values(tracker.templates).map(entry => ({
|
||
templateId: entry.templateId,
|
||
finalVideoUrl: entry.finalVideoUrl,
|
||
segments: entry.segments.map(segment => ({
|
||
part: segment.part,
|
||
taskId: segment.taskId,
|
||
status: segment.status,
|
||
hasFile: Boolean(segment.filePath),
|
||
})),
|
||
}));
|
||
console.log(JSON.stringify(summary, null, 2));
|
||
}
|
||
|
||
function safe(value) {
|
||
return String(value).replace(/[^a-zA-Z0-9_.-]+/g, '_').slice(0, 120);
|
||
}
|
||
|
||
function sleep(ms) {
|
||
return new Promise(resolve => setTimeout(resolve, ms));
|
||
}
|
||
|
||
function fail(message) {
|
||
console.error(message);
|
||
process.exit(1);
|
||
}
|