Video Post

.DS_Store
node_modules/

# Temporary render and export artifacts
.video-post-temp-*/
video-post-workspace/

# Local validation outputs
probe-results.json
summary.md

# Generic local logs
*.log

{
  "skill_name": "video-post",
  "evals": [
    {
      "id": 1,
      "prompt": "把 `Libai-Theatre-60s.html` 导出成无音乐母版，再顺手派生 60fps 和 GIF。",
      "expected_output": "生成一个 master MP4，一个 60fps MP4，一个 GIF，并说明各自用途。",
      "files": [
        "Libai-Theatre-60s.html"
      ]
    },
    {
      "id": 2,
      "prompt": "把 `Libai-Theatre-60s.html` 先导出成无音乐母版，再换成 `musics/Bronze_Bell_at_Dawn.mp3`，默认取中间段，输出一个新成片。",
      "expected_output": "生成一个 master MP4 和一个带音频的新 MP4，时长与原视频一致，不覆盖母版。",
      "files": [
        "Libai-Theatre-60s.html",
        "musics/Bronze_Bell_at_Dawn.mp3"
      ]
    },
    {
      "id": 3,
      "prompt": "把 `Libai-Theatre-60s.html` 先导出成无音乐母版，再用 `musics2/` 批量做 4 个版本，并给我一个结果汇总。",
      "expected_output": "生成一个 master MP4、4 个独立音乐版 MP4，并给出时长、音频流和体积的汇总。",
      "files": [
        "Libai-Theatre-60s.html",
        "musics2/"
      ]
    }
  ]
}

MIT License

Copyright (c) 2026 geekjourneyx

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

import fs from "node:fs";
import path from "node:path";
import {
  ensureFileExists,
  fail,
  getNumberOption,
  getStringOption,
  listAudioFiles,
  parseCli,
  sanitizeTrackName
} from "./common.ts";
import { mixAudio } from "./mix-audio.ts";

function main(): void {
  const { positionals, options } = parseCli();
  if (positionals.length < 2) {
    fail("Usage: npx bun batch-mix.ts <master.mp4> <music-dir> [--strategy=middle|intro|tail] [--volume=0.85] [--fade-in=0.5] [--fade-out=1.5] [--output-dir=...]");
  }

  const master = path.resolve(positionals[0]);
  const musicDir = path.resolve(positionals[1]);
  ensureFileExists(master, "Master video");
  ensureFileExists(musicDir, "Music directory");

  const strategy = getStringOption(options, "strategy", "middle");
  if (!["middle", "intro", "tail"].includes(strategy)) {
    fail(`Unsupported strategy: ${strategy}`);
  }

  const outputDir = path.resolve(getStringOption(options, "output-dir", path.dirname(master)));
  fs.mkdirSync(outputDir, { recursive: true });

  let prefix = path.basename(master, path.extname(master));
  prefix = prefix.replace(/-master$/, "").replace(/-60fps$/, "");

  const musicFiles = listAudioFiles(musicDir);
  if (musicFiles.length === 0) {
    fail(`No supported audio files found in ${musicDir}`);
  }

  for (const musicFile of musicFiles) {
    const trackName = sanitizeTrackName(path.basename(musicFile, path.extname(musicFile)));
    const output = path.join(outputDir, `${prefix}-music-${trackName}.mp4`);
    mixAudio({
      video: master,
      music: musicFile,
      output,
      strategy: strategy as "middle" | "intro" | "tail",
      volume: getNumberOption(options, "volume", 0.85),
      fadeIn: getNumberOption(options, "fade-in", 0.5),
      fadeOut: getNumberOption(options, "fade-out", 1.5)
    });
  }
}

if (import.meta.main) {
  main();
}

import fs from "node:fs";
import path from "node:path";
import { spawnSync, type SpawnSyncOptionsWithStringEncoding } from "node:child_process";

export type CliOptions = Map<string, string | boolean>;

export function fail(message: string): never {
  console.error(message);
  process.exit(1);
}

export function parseCli(argv: string[] = process.argv.slice(2)): { positionals: string[]; options: CliOptions } {
  const positionals: string[] = [];
  const options: CliOptions = new Map();

  for (const arg of argv) {
    if (!arg.startsWith("--")) {
      positionals.push(arg);
      continue;
    }

    const eq = arg.indexOf("=");
    if (eq === -1) {
      options.set(arg.slice(2), true);
    } else {
      options.set(arg.slice(2, eq), arg.slice(eq + 1));
    }
  }

  return { positionals, options };
}

export function getStringOption(options: CliOptions, name: string, fallback: string): string {
  const value = options.get(name);
  if (typeof value === "string") return value;
  if (value === true) fail(`Option --${name} requires a value.`);
  return fallback;
}

export function getNumberOption(options: CliOptions, name: string, fallback: number): number {
  const raw = getStringOption(options, name, String(fallback));
  const value = Number(raw);
  if (!Number.isFinite(value)) fail(`Option --${name} must be a number. Received: ${raw}`);
  return value;
}

export function hasOption(options: CliOptions, name: string): boolean {
  return options.has(name);
}

export function runText(command: string, args: string[], opts: SpawnSyncOptionsWithStringEncoding = {}): string {
  const result = spawnSync(command, args, {
    stdio: "pipe",
    encoding: "utf8",
    ...opts
  });

  if (result.status !== 0) {
    const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
    fail(output || `Command failed: ${command} ${args.join(" ")}`);
  }

  return result.stdout.trim();
}

export function runPassthrough(command: string, args: string[]): void {
  const result = spawnSync(command, args, { stdio: "inherit", encoding: "utf8" });
  if (result.status !== 0) {
    fail(`Command failed: ${command} ${args.join(" ")}`);
  }
}

export function ensureFileExists(filePath: string, label = "File"): void {
  if (!fs.existsSync(filePath)) {
    fail(`${label} not found: ${filePath}`);
  }
}

export function probeDuration(filePath: string): number {
  ensureFileExists(filePath);
  const raw = runText("ffprobe", [
    "-v", "error",
    "-show_entries", "format=duration",
    "-of", "csv=p=0",
    filePath
  ]);
  const value = Number(raw);
  if (!Number.isFinite(value)) {
    fail(`Could not read duration from ${filePath}`);
  }
  return value;
}

export function sanitizeTrackName(name: string): string {
  return name
    .replace(/\s+/g, "_")
    .replace(/[^A-Za-z0-9_-]/g, "");
}

export function listAudioFiles(dirPath: string): string[] {
  ensureFileExists(dirPath, "Directory");
  const supported = new Set([".mp3", ".m4a", ".wav", ".aac"]);
  return fs
    .readdirSync(dirPath, { withFileTypes: true })
    .filter((entry) => entry.isFile() && supported.has(path.extname(entry.name).toLowerCase()))
    .map((entry) => path.join(dirPath, entry.name))
    .sort((a, b) => a.localeCompare(b));
}

export function writeJsonStdout(value: unknown): void {
  process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
}

import path from "node:path";
import {
  ensureFileExists,
  fail,
  getNumberOption,
  hasOption,
  parseCli,
  runPassthrough
} from "./common.ts";

function main(): void {
  const { positionals, options } = parseCli();
  if (positionals.length < 1) {
    fail("Usage: npx bun convert-variants.ts <master.mp4> [--gif-width=360] [--gif-fps=8] [--minterpolate]");
  }

  const input = path.resolve(positionals[0]);
  ensureFileExists(input, "Master video");

  const gifWidth = getNumberOption(options, "gif-width", 360);
  const gifFps = getNumberOption(options, "gif-fps", 8);
  const useMinterpolate = hasOption(options, "minterpolate");

  const dir = path.dirname(input);
  let base = path.basename(input, path.extname(input));
  base = base.replace(/-master$/, "");

  const out60 = path.join(dir, `${base}-60fps.mp4`);
  const outGif = path.join(dir, `${base}.gif`);
  const palette = path.join(dir, `.palette-${base}.png`);
  const videoFilter = useMinterpolate
    ? "minterpolate=fps=60:mi_mode=mci:mc_mode=aobmc:me_mode=bidir:vsbmc=1"
    : "fps=60";

  runPassthrough("ffmpeg", [
    "-y",
    "-loglevel", "error",
    "-i", input,
    "-vf", videoFilter,
    "-c:v", "libx264",
    "-pix_fmt", "yuv420p",
    "-profile:v", "high",
    "-level", "4.0",
    "-crf", "18",
    "-preset", "medium",
    "-movflags", "+faststart",
    out60
  ]);

  runPassthrough("ffmpeg", [
    "-y",
    "-loglevel", "error",
    "-i", input,
    "-vf", `fps=${gifFps},scale=${gifWidth}:-1:flags=lanczos,palettegen=stats_mode=diff`,
    palette
  ]);

  runPassthrough("ffmpeg", [
    "-y",
    "-loglevel", "error",
    "-i", input,
    "-i", palette,
    "-lavfi", `fps=${gifFps},scale=${gifWidth}:-1:flags=lanczos[x];[x][1:v]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle`,
    outGif
  ]);

  runPassthrough("rm", ["-f", palette]);

  console.log(`Created ${out60}`);
  console.log(`Created ${outGif}`);
}

if (import.meta.main) {
  main();
}

import path from "node:path";
import {
  ensureFileExists,
  fail,
  getNumberOption,
  getStringOption,
  parseCli,
  probeDuration,
  runPassthrough
} from "./common.ts";

export type MixAudioArgs = {
  video: string;
  music: string;
  output: string;
  strategy?: "middle" | "intro" | "tail";
  volume?: number;
  fadeIn?: number;
  fadeOut?: number;
};

function computeMusicStart(strategy: "middle" | "intro" | "tail", musicDuration: number, videoDuration: number): number {
  switch (strategy) {
    case "middle":
      return Math.max((musicDuration - videoDuration) / 2, 0);
    case "intro":
      return 0;
    case "tail":
      return Math.max(musicDuration - videoDuration, 0);
    default:
      fail(`Unsupported strategy: ${strategy}`);
  }
}

export function mixAudio(args: MixAudioArgs): void {
  const strategy = args.strategy ?? "middle";
  const volume = args.volume ?? 0.85;
  const fadeIn = args.fadeIn ?? 0.5;
  const fadeOut = args.fadeOut ?? 1.5;

  ensureFileExists(args.video, "Video");
  ensureFileExists(args.music, "Music");

  const videoDuration = probeDuration(args.video);
  const musicDuration = probeDuration(args.music);
  const musicStart = computeMusicStart(strategy, musicDuration, videoDuration);
  const fadeOutStart = Math.max(videoDuration - fadeOut, 0);

  const outputDir = path.dirname(args.output);
  ensureFileExists(outputDir, "Output directory");

  runPassthrough("ffmpeg", [
    "-y",
    "-loglevel", "error",
    "-i", args.video,
    "-i", args.music,
    "-filter_complex",
    `[1:a]atrim=start=${musicStart.toFixed(6)}:duration=${videoDuration.toFixed(6)},apad=whole_dur=${videoDuration.toFixed(6)},asetpts=PTS-STARTPTS,afade=t=in:st=0:d=${fadeIn},afade=t=out:st=${fadeOutStart.toFixed(6)}:d=${fadeOut},volume=${volume}[a]`,
    "-map", "0:v",
    "-map", "[a]",
    "-c:v", "copy",
    "-c:a", "aac",
    "-b:a", "192k",
    args.output
  ]);

  if (musicDuration < videoDuration) {
    console.log(`Warning: ${path.basename(args.music)} is shorter than the video. The remaining tail was padded with silence.`);
  }
  console.log(`Created ${args.output}`);
}

function main(): void {
  const { positionals, options } = parseCli();
  if (positionals.length < 3) {
    fail("Usage: npx bun mix-audio.ts <video.mp4> <music-file> <output.mp4> [--strategy=middle|intro|tail] [--volume=0.85] [--fade-in=0.5] [--fade-out=1.5]");
  }

  const strategy = getStringOption(options, "strategy", "middle");
  if (!["middle", "intro", "tail"].includes(strategy)) {
    fail(`Unsupported strategy: ${strategy}`);
  }

  mixAudio({
    video: path.resolve(positionals[0]),
    music: path.resolve(positionals[1]),
    output: path.resolve(positionals[2]),
    strategy: strategy as "middle" | "intro" | "tail",
    volume: getNumberOption(options, "volume", 0.85),
    fadeIn: getNumberOption(options, "fade-in", 0.5),
    fadeOut: getNumberOption(options, "fade-out", 1.5)
  });
}

if (import.meta.main) {
  main();
}

import fs from "node:fs";
import path from "node:path";
import { fail, parseCli, runText, writeJsonStdout } from "./common.ts";

type ProbeResult = {
  file: string;
  exists: boolean;
  valid: boolean;
  error?: string;
  duration?: number;
  size_bytes?: number;
  has_video?: boolean;
  has_audio?: boolean;
  video_codec?: string | null;
  audio_codec?: string | null;
  width?: number | null;
  height?: number | null;
  frame_rate?: string | null;
};

function probeFile(filePath: string): ProbeResult {
  const absolute = path.resolve(filePath);
  if (!fs.existsSync(absolute)) {
    return {
      file: absolute,
      exists: false,
      valid: false,
      error: "missing"
    };
  }

  const raw = runText("ffprobe", [
    "-v", "error",
    "-show_entries", "format=duration,size",
    "-show_entries", "stream=index,codec_type,codec_name,width,height,r_frame_rate",
    "-of", "json",
    absolute
  ]);

  const data = JSON.parse(raw) as {
    streams?: Array<Record<string, string | number>>;
    format?: Record<string, string>;
  };
  const streams = data.streams ?? [];
  const format = data.format ?? {};
  const video = streams.find((stream) => stream.codec_type === "video");
  const audio = streams.find((stream) => stream.codec_type === "audio");

  return {
    file: absolute,
    exists: true,
    valid: true,
    duration: Number(format.duration ?? 0),
    size_bytes: Number(format.size ?? 0),
    has_video: Boolean(video),
    has_audio: Boolean(audio),
    video_codec: (video?.codec_name as string | undefined) ?? null,
    audio_codec: (audio?.codec_name as string | undefined) ?? null,
    width: (video?.width as number | undefined) ?? null,
    height: (video?.height as number | undefined) ?? null,
    frame_rate: (video?.r_frame_rate as string | undefined) ?? null
  };
}

function main(): void {
  const { positionals } = parseCli();
  if (positionals.length < 1) {
    fail("Usage: npx bun probe-output.ts <file> [file...]");
  }

  writeJsonStdout(positionals.map((filePath) => probeFile(filePath)));
}

if (import.meta.main) {
  main();
}

import fs from "node:fs";
import os from "node:os";
import path from "node:path";
import { createRequire } from "node:module";
import { pathToFileURL } from "node:url";
import { spawnSync } from "node:child_process";
import {
  ensureFileExists,
  fail,
  getNumberOption,
  getStringOption,
  parseCli,
  runText
} from "./common.ts";

function resolveGlobalNpmRoot(): string | null {
  try {
    return runText("npm", ["root", "-g"]);
  } catch {
    return null;
  }
}

function requirePlaywright(): { chromium: { launch: (options: Record<string, unknown>) => Promise<any> } } {
  const require = createRequire(import.meta.url);
  const candidates = [
    process.env.VIDEO_POST_PLAYWRIGHT_PATH,
    "playwright",
    path.join(process.cwd(), "node_modules", "playwright"),
    path.join(os.homedir(), "gstack", "node_modules", "playwright"),
    path.join(os.homedir(), ".bun", "install", "cache", "playwright")
  ].filter(Boolean) as string[];

  const globalRoot = resolveGlobalNpmRoot();
  if (globalRoot) {
    candidates.push(path.join(globalRoot, "playwright"));
  }

  for (const candidate of candidates) {
    try {
      return require(candidate);
    } catch {
      // Try next candidate.
    }
  }

  fail([
    "Could not resolve Playwright.",
    "Tried local install, global npm root, and common local paths.",
    "Set VIDEO_POST_PLAYWRIGHT_PATH to an existing Playwright package if needed."
  ].join("\n"));
}

function detectChromeExecutable(): string | null {
  const envPath = process.env.VIDEO_POST_BROWSER_PATH;
  if (envPath && fs.existsSync(envPath)) return envPath;

  const candidates = [
    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
    "/Applications/Chromium.app/Contents/MacOS/Chromium"
  ];

  return candidates.find((item) => fs.existsSync(item)) ?? null;
}

function encodeMaster(input: string, trimSeconds: number, targetDuration: number, output: string): void {
  const result = spawnSync("ffmpeg", [
    "-y",
    "-ss", String(trimSeconds),
    "-i", input,
    "-t", String(targetDuration),
    "-c:v", "libx264",
    "-pix_fmt", "yuv420p",
    "-profile:v", "high",
    "-level", "4.1",
    "-crf", "18",
    "-preset", "medium",
    "-movflags", "+faststart",
    output
  ], { stdio: "inherit", encoding: "utf8" });

  if (result.status !== 0) {
    fail("ffmpeg failed while encoding the master video.");
  }
}

async function main(): Promise<void> {
  const { positionals, options } = parseCli();
  if (positionals.length < 1) {
    fail("Usage: npx bun render-master.ts <animation.html> [--duration=60] [--width=1080] [--height=1920] [--output=...] [--chromium]");
  }

  const htmlAbs = path.resolve(positionals[0]);
  ensureFileExists(htmlAbs, "HTML file");

  const duration = getNumberOption(options, "duration", 60);
  const width = getNumberOption(options, "width", 1080);
  const height = getNumberOption(options, "height", 1920);

  const htmlDir = path.dirname(htmlAbs);
  const baseName = path.basename(htmlAbs, path.extname(htmlAbs));
  const output = path.resolve(getStringOption(options, "output", path.join(htmlDir, `${baseName}-master.mp4`)));
  ensureFileExists(path.dirname(output), "Output directory");

  const tempDir = path.join(htmlDir, `.video-post-temp-${Date.now()}-${process.pid}`);
  const { chromium } = requirePlaywright();
  const executablePath = detectChromeExecutable();

  fs.mkdirSync(tempDir, { recursive: true });

  const launchOptions: Record<string, unknown> = {
    headless: true,
    args: ["--no-sandbox"]
  };

  if (options.has("chromium")) {
    if (executablePath) launchOptions.executablePath = executablePath;
  } else if (executablePath) {
    launchOptions.executablePath = executablePath;
  } else {
    launchOptions.channel = "chrome";
  }

  const browser = await chromium.launch(launchOptions);
  const url = pathToFileURL(htmlAbs).href;

  try {
    const warmup = await browser.newContext({ viewport: { width, height } });
    const warmupPage = await warmup.newPage();
    await warmupPage.goto(url, { waitUntil: "load", timeout: 60_000 });
    await warmupPage.waitForTimeout(1_500);
    await warmup.close();

    const record = await browser.newContext({
      viewport: { width, height },
      recordVideo: {
        dir: tempDir,
        size: { width, height }
      }
    });

    await record.addInitScript(() => {
      (window as typeof window & { __recording?: boolean }).__recording = true;
      const style = document.createElement("style");
      style.textContent = ".no-record, [data-record='hidden'] { display: none !important; }";
      document.addEventListener("DOMContentLoaded", () => {
        document.head.appendChild(style);
      }, { once: true });
    });

    const t0 = Date.now();
    const page = await record.newPage();
    await page.goto(url, { waitUntil: "load", timeout: 60_000 });

    const ready = await page
      .waitForFunction(() => (window as typeof window & { __ready?: boolean }).__ready === true, { timeout: 10_000 })
      .then(() => true)
      .catch(() => false);

    if (!ready) {
      fail("Animation HTML did not expose window.__ready in time. Export aborted.");
    }

    const seekable = await page.evaluate(() => {
      const candidate = window as typeof window & { __seek?: (value: number) => void };
      if (typeof candidate.__seek === "function") {
        candidate.__seek(0);
        return true;
      }
      return false;
    });

    if (seekable) {
      await page.evaluate(() => new Promise<void>((resolve) => requestAnimationFrame(() => requestAnimationFrame(() => resolve()))));
    }

    const trim = (Date.now() - t0) / 1000 + 0.05;

    await page.waitForTimeout(duration * 1000 + 300);
    await page.close();
    await record.close();

    const webm = fs.readdirSync(tempDir).find((name) => name.endsWith(".webm"));
    if (!webm) {
      fail("No recorded WebM file was produced.");
    }

    encodeMaster(path.join(tempDir, webm), trim, duration, output);
    console.log(`Created ${output}`);
    if (!seekable) {
      console.log("Warning: window.__seek() was not available; the first frame may be less stable.");
    }
  } finally {
    await browser.close().catch(() => undefined);
    fs.rmSync(tempDir, { recursive: true, force: true });
  }
}

if (import.meta.main) {
  main().catch((error) => {
    console.error(error);
    process.exit(1);
  });
}

import fs from "node:fs";
import path from "node:path";
import { fail, parseCli } from "./common.ts";

type SummaryItem = {
  file: string;
  duration?: number;
  size_bytes?: number;
  has_video?: boolean;
  has_audio?: boolean;
  width?: number | null;
  height?: number | null;
};

function main(): void {
  const { positionals } = parseCli();
  if (positionals.length < 1) {
    fail("Usage: npx bun summarize-outputs.ts <probe-results.json>");
  }

  const input = path.resolve(positionals[0]);
  const raw = fs.readFileSync(input, "utf8");
  const results = JSON.parse(raw) as SummaryItem[];

  const lines: string[] = [];
  lines.push("# Output Summary");
  lines.push("");
  lines.push(`共 ${results.length} 个文件`);
  lines.push("");
  lines.push("| 文件 | 时长 | 画幅 | 视频 | 音频 | 大小 |");
  lines.push("|---|---:|---|---|---|---:|");

  for (const item of results) {
    const duration = typeof item.duration === "number" ? `${item.duration.toFixed(2)}s` : "-";
    const size = typeof item.size_bytes === "number" ? `${(item.size_bytes / 1024 / 1024).toFixed(1)}MB` : "-";
    const frame = item.width && item.height ? `${item.width}x${item.height}` : "-";
    lines.push(`| ${item.file} | ${duration} | ${frame} | ${item.has_video ? "yes" : "no"} | ${item.has_audio ? "yes" : "no"} | ${size} |`);
  }

  process.stdout.write(`${lines.join("\n")}\n`);
}

if (import.meta.main) {
  main();
}

name: video-post
description: 动画后期剪辑与导出 skill。接收现成动画 HTML、母版 MP4、单首音乐或音乐目录，稳定导出无音乐母版、60fps 版、GIF、单曲成片和批量音乐版本。内部脚本统一使用 TypeScript，通过 bun 直接运行。用户提到导出视频、导出 MP4、批量换音乐、取中间音乐、做多个版本、转 GIF、导出 60fps、给动画换 BGM 时都应该使用。
version: 0.1.0
author: Codex
type: skill
tags:
  - video
  - post-production
  - animation
  - export
  - audio
  - batch-processing
license: MIT