caelum0x f47db146eb feat: add batch/portfolio render command for multi-product manifests
tools/batch.mjs (and the film/render-all.sh wrapper) accepts a JSON
manifest of N products, each with a brand source (URL or existing
brand kit), an optional screenshots dir and a film.json body, and
renders every one in a single pass: stage brand + screenshots +
film.json into this repo's own film/ and brand/, run the real
render.sh pipeline, copy the output into renders/<product>/<hook>*.mp4,
then restore this repo's example state before moving to the next
product (always, even on failure). Writes a combined
renders/batch-report.json summary.

Turns the ad-hoc by-hand workflow (swap film.json, render, repeat,
already used across several products) into one documented, reusable
command.
2026-10-23 15:14:41 +03:00

228 lines
10 KiB
JavaScript
Executable File

#!/usr/bin/env node
// Batch/portfolio render: render N products' launch films in one pass from a single JSON
// manifest. This kit's render pipeline is single-project (one film/film.json, one brand/, one
// film/assets/screens/ at a time) so batch.mjs stages each product's brand, screenshots and
// film.json into those paths in turn, runs the real film/render.sh engine, copies the result
// into renders/<product>/<hook>[-vertical|-square].mp4, then restores the repo's own example
// state before moving to the next product - and always restores, even if a product fails.
//
// This turns the owner's own by-hand workflow (cd into film/, swap film.json, render, repeat -
// already used across caldesk/menivor/scribase/etc.) into one documented, reusable command
// instead of ad-hoc scripting, per STRATEGY-2026-10-23.md's Move 3 dogfooding path.
//
// node tools/batch.mjs manifest.json [--only name1,name2] [--format landscape|vertical|square|all]
// film/render-all.sh manifest.json (thin wrapper around this file)
//
// manifest.json:
// { "products": [
// { "name": "caldesk", # required, also the output subfolder name
// "url": "https://caldesk.app", # extract a fresh brand kit from this URL ...
// "brand": "/abs/path/to/existing/brand", # ... or reuse an already-reviewed brand kit (pick one)
// "screens": "/abs/or/repo-relative/dir", # optional: copied into film/assets/screens/ first
// "film": { ... a film.json body ... } | "path/to/film.json", # required
// "hooks": ["type-only"], # optional, default ["type-only"]
// "format": "landscape" }, ... # optional, overrides the global --format for this product
// ] }
import { spawnSync } from 'node:child_process';
import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
const here = path.dirname(fileURLToPath(import.meta.url));
const root = path.resolve(here, '..');
const FILM = path.join(root, 'film');
const BRAND = path.join(root, 'brand');
const SCREENS = path.join(FILM, 'assets', 'screens');
const FILM_JSON = path.join(FILM, 'film.json');
const OUT = path.join(root, 'renders');
function usage() {
console.error(`Usage: node tools/batch.mjs <manifest.json> [--only name1,name2] [--format landscape|vertical|square|all]
Renders every product in the manifest's "products" array, writing renders/<product>/<hook>*.mp4
and a combined renders/batch-report.json. See the header of this file for the manifest shape.`);
}
function parseArgs(argv) {
const a = { manifest: null, only: null, format: null };
for (let i = 0; i < argv.length; i++) {
const v = argv[i];
if (v === '--only') a.only = argv[++i].split(',').map((s) => s.trim()).filter(Boolean);
else if (v === '--format') a.format = argv[++i];
else if (v === '-h' || v === '--help') a.help = true;
else if (!a.manifest) a.manifest = v;
}
return a;
}
// ------------------------------------------------------------------ stage / restore
// Moves the repo's live brand/, film/assets/screens/ and film/film.json aside, runs `work`,
// then always puts them back - a product's render never permanently changes this repo's own
// checked-in example state, win or lose.
async function withStagedState(work) {
const brandBak = `${BRAND}.batch-orig`;
const screensBak = `${SCREENS}.batch-orig`;
const filmJsonOrig = fs.existsSync(FILM_JSON) ? fs.readFileSync(FILM_JSON, 'utf8') : null;
if (fs.existsSync(BRAND)) fs.renameSync(BRAND, brandBak);
if (fs.existsSync(SCREENS)) fs.renameSync(SCREENS, screensBak);
try {
return await work();
} finally {
fs.rmSync(BRAND, { recursive: true, force: true });
fs.rmSync(SCREENS, { recursive: true, force: true });
if (fs.existsSync(brandBak)) fs.renameSync(brandBak, BRAND);
if (fs.existsSync(screensBak)) fs.renameSync(screensBak, SCREENS);
if (filmJsonOrig !== null) fs.writeFileSync(FILM_JSON, filmJsonOrig);
}
}
function copyDirContents(src, dst) {
fs.mkdirSync(dst, { recursive: true });
for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
const s = path.join(src, entry.name);
const d = path.join(dst, entry.name);
if (entry.isDirectory()) copyDirContents(s, d);
else fs.copyFileSync(s, d);
}
}
async function stageBrand(product) {
fs.mkdirSync(BRAND, { recursive: true });
if (product.brand) {
const src = path.resolve(root, product.brand);
if (!fs.existsSync(path.join(src, 'brand.json'))) throw new Error(`"brand" dir has no brand.json: ${src}`);
copyDirContents(src, BRAND);
return { mode: 'reused', from: src };
}
if (product.url) {
const tool = path.join(root, 'tools', 'brand-from-url.mjs');
const r = spawnSync(process.execPath, [tool, product.url, '--out', 'brand'], { cwd: root, encoding: 'utf8' });
if (r.status !== 0) throw new Error(`brand extraction failed for ${product.url}:\n${(r.stderr || r.stdout || '').slice(-2000)}`);
return { mode: 'extracted', from: product.url };
}
throw new Error('product needs either "url" (extract) or "brand" (reuse an existing kit)');
}
function stageScreens(product) {
if (!product.screens) return { mode: 'none' };
const src = path.resolve(root, product.screens);
if (!fs.existsSync(src)) throw new Error(`"screens" dir does not exist: ${src}`);
copyDirContents(src, SCREENS);
return { mode: 'copied', from: src };
}
function stageFilm(product) {
if (!product.film) throw new Error('product needs a "film" (inline film.json body, or a path to one)');
const body = typeof product.film === 'string' ? JSON.parse(fs.readFileSync(path.resolve(root, product.film), 'utf8')) : product.film;
fs.writeFileSync(FILM_JSON, JSON.stringify(body, null, 2) + '\n');
}
// ------------------------------------------------------------------ render + collect
const SUF_NAME = { landscape: '', vertical: '-vertical', square: '-square' };
function renderHook(hook, format) {
const args = ['render.sh'];
if (format && format !== 'landscape') args.push('--format', format === 'all' ? 'all' : format);
args.push(hook);
const t0 = Date.now();
const r = spawnSync('bash', args, { cwd: FILM, encoding: 'utf8' });
const seconds = (Date.now() - t0) / 1000;
return { ok: r.status === 0, seconds, stdout: r.stdout || '', stderr: r.stderr || '' };
}
function collectOutputs(productDir, hook, format) {
const formats = format === 'all' ? ['landscape', 'vertical', 'square'] : [format || 'landscape'];
const out = [];
for (const f of formats) {
const name = `${hook}${SUF_NAME[f] ?? ''}.mp4`;
const src = path.join(FILM, 'renders', name);
if (!fs.existsSync(src)) { out.push({ format: f, ok: false, error: `missing ${src}` }); continue; }
fs.mkdirSync(productDir, { recursive: true });
const dest = path.join(productDir, name);
fs.copyFileSync(src, dest);
out.push({ format: f, ok: true, path: path.relative(root, dest), bytes: fs.statSync(dest).size });
}
return out;
}
// ------------------------------------------------------------------ main
async function main() {
const args = parseArgs(process.argv.slice(2));
if (args.help || !args.manifest) { usage(); process.exit(args.help ? 0 : 1); }
if (!fs.existsSync(args.manifest)) { console.error(`batch: no such manifest: ${args.manifest}`); process.exit(1); }
let manifest;
try {
manifest = JSON.parse(fs.readFileSync(args.manifest, 'utf8'));
} catch (err) {
console.error(`batch: cannot parse ${args.manifest}: ${err.message}`);
process.exit(1);
}
const products = manifest.products;
if (!Array.isArray(products) || products.length === 0) {
console.error(`batch: ${args.manifest} needs a non-empty "products" array`);
process.exit(1);
}
const selected = args.only ? products.filter((p) => args.only.includes(p.name)) : products;
if (selected.length === 0) {
console.error(`batch: --only matched nothing (have: ${products.map((p) => p.name).join(', ')})`);
process.exit(1);
}
fs.mkdirSync(OUT, { recursive: true });
const report = { manifest: path.resolve(args.manifest), started: new Date().toISOString(), products: [] };
for (const product of selected) {
if (!product.name) { console.error('batch: a product is missing "name", skipping'); continue; }
console.log(`\n=== ${product.name} ===`);
const entry = { name: product.name, hooks: [] };
report.products.push(entry);
const format = product.format || args.format || 'landscape';
try {
await withStagedState(async () => {
const brandInfo = await stageBrand(product);
console.log(` brand: ${brandInfo.mode} (${brandInfo.from})`);
const screenInfo = stageScreens(product);
if (screenInfo.mode === 'copied') console.log(` screens: copied from ${screenInfo.from}`);
stageFilm(product);
const hooks = product.hooks?.length ? product.hooks : ['type-only'];
const productDir = path.join(OUT, product.name);
for (const hook of hooks) {
const r = renderHook(hook, format);
if (!r.ok) {
console.error(` ${hook} (${format}): FAILED (${r.seconds.toFixed(1)}s)`);
entry.hooks.push({ hook, format, ok: false, seconds: r.seconds, error: (r.stderr || r.stdout || '').slice(-2000) });
continue;
}
const outputs = collectOutputs(productDir, hook, format);
const allOk = outputs.every((o) => o.ok);
console.log(` ${hook} (${format}): ${allOk ? 'ok' : 'partial'} (${r.seconds.toFixed(1)}s) -> ${outputs.filter((o) => o.ok).map((o) => o.path).join(', ')}`);
entry.hooks.push({ hook, format, ok: allOk, seconds: r.seconds, outputs });
}
});
} catch (err) {
console.error(` ${product.name}: ${err.message}`);
entry.error = err.message;
}
}
report.finished = new Date().toISOString();
const reportPath = path.join(OUT, 'batch-report.json');
fs.writeFileSync(reportPath, JSON.stringify(report, null, 2) + '\n');
const totalHooks = report.products.reduce((n, p) => n + p.hooks.length, 0);
const okHooks = report.products.reduce((n, p) => n + p.hooks.filter((h) => h.ok).length, 0);
console.log(`\nbatch: ${okHooks}/${totalHooks} render(s) ok across ${report.products.length} product(s) -> ${path.relative(root, reportPath)}`);
if (okHooks < totalHooks) process.exitCode = 1;
}
main();