rollberry 0.1.9 → 0.2.0

package/dist/options.js

@@ -3,12 +3,12 @@ import { parseArgs } from 'node:util';
 import { MAX_FPS } from './capture/constants.js';
 import { parseCaptureUrl, validateHideSelector } from './capture/utils.js';
 import { VERSION } from './version.js';
-const DEFAULT_OUT_FILE = 'rollberry.mp4';
-const DEFAULT_VIEWPORT = '1440x900';
-const DEFAULT_FPS = 60;
-const DEFAULT_DURATION = 'auto';
-const DEFAULT_MOTION = 'ease-in-out-sine';
-const DEFAULT_TIMEOUT_MS = 30_000;
+export const DEFAULT_OUT_FILE = 'rollberry.mp4';
+export const DEFAULT_VIEWPORT = '1440x900';
+export const DEFAULT_FPS = 60;
+export const DEFAULT_DURATION = 'auto';
+export const DEFAULT_MOTION = 'ease-in-out-sine';
+export const DEFAULT_TIMEOUT_MS = 30_000;
 export class CliError extends Error {
     showUsage;
     constructor(message, showUsage = false) {
@@ -30,7 +30,7 @@ export class VersionRequest extends Error {
         this.name = 'VersionRequest';
     }
 }
-export function parseCliArgs(argv = process.argv.slice(2)) {
+export function parseCommandArgs(argv = process.argv.slice(2)) {
     const [command, ...rest] = argv;
     if (command === '--help' || command === '-h') {
         throw new HelpRequest(formatUsage());
@@ -39,120 +39,32 @@ export function parseCliArgs(argv = process.argv.slice(2)) {
         throw new VersionRequest();
     }
     if (!command) {
-        throw new CliError('A subcommand is required.\n\nAvailable commands:\n  capture    Capture a scroll video from one or more URLs\n\nRun rollberry --help for more information.');
-    }
-    if (command !== 'capture') {
-        throw new CliError(`Unknown subcommand: ${command}\n\nAvailable commands:\n  capture    Capture a scroll video from one or more URLs\n\nRun rollberry --help for more information.`);
-    }
-    if (rest.includes('--help') || rest.includes('-h')) {
-        throw new HelpRequest(formatUsage());
+        throw createMissingSubcommandError();
     }
-    const parsed = parseArgs({
-        args: rest,
-        allowPositionals: true,
-        options: {
-            out: {
-                type: 'string',
-            },
-            viewport: {
-                type: 'string',
-            },
-            fps: {
-                type: 'string',
-            },
-            duration: {
-                type: 'string',
-            },
-            motion: {
-                type: 'string',
-            },
-            timeout: {
-                type: 'string',
-            },
-            'wait-for': {
-                type: 'string',
-            },
-            'hide-selector': {
-                type: 'string',
-                multiple: true,
-            },
-            'debug-frames-dir': {
-                type: 'string',
-            },
-            'page-gap': {
-                type: 'string',
-            },
-            manifest: {
-                type: 'string',
-            },
-            'log-file': {
-                type: 'string',
-            },
-            force: {
-                type: 'boolean',
-            },
-        },
-        strict: true,
-    });
-    if (parsed.positionals.length === 0) {
-        throw new CliError('capture requires at least one URL.', true);
+    switch (command) {
+        case 'capture':
+            return { kind: 'capture', options: parseCaptureArgs(rest) };
+        case 'render':
+            return { kind: 'render', options: parseRenderArgs(rest) };
+        default:
+            throw createUnknownSubcommandError(command);
     }
-    const urls = parsed.positionals.map((raw) => parseWithCliError(raw, parseCaptureUrl));
-    const durationOption = parsed.values.duration ?? DEFAULT_DURATION;
-    if (durationOption !== 'auto' && Number.isNaN(Number(durationOption))) {
-        throw new CliError(`--duration must be "auto" or a positive number (e.g. --duration 5): ${durationOption}`);
-    }
-    const outPath = resolveOutPath(parsed.values.out ?? DEFAULT_OUT_FILE);
-    const pageGapSeconds = parseWithCliError(parsed.values['page-gap'] ?? '0', parseNonNegativeNumber);
-    const hideSelectors = parsed.values['hide-selector'] ?? [];
-    for (const selector of hideSelectors) {
-        parseWithCliError(selector, validateHideSelector);
-    }
-    const fps = parseWithCliError(parsed.values.fps ?? String(DEFAULT_FPS), parsePositiveInt);
-    if (fps > MAX_FPS) {
-        throw new CliError(`--fps must be at most ${MAX_FPS}: ${fps}`);
-    }
-    return {
-        urls: toNonEmptyArray(urls),
-        outPath,
-        manifestPath: parsed.values.manifest
-            ? resolveOutPath(parsed.values.manifest)
-            : deriveSidecarPath(outPath, '.manifest.json'),
-        logFilePath: parsed.values['log-file']
-            ? resolveOutPath(parsed.values['log-file'])
-            : deriveSidecarPath(outPath, '.log.jsonl'),
-        viewport: parseWithCliError(parsed.values.viewport ?? DEFAULT_VIEWPORT, parseViewport),
-        fps,
-        duration: durationOption === 'auto'
-            ? 'auto'
-            : parseWithCliError(durationOption, parsePositiveNumber),
-        motion: parseWithCliError(parsed.values.motion ?? DEFAULT_MOTION, parseMotion),
-        timeoutMs: parseWithCliError(parsed.values.timeout ?? String(DEFAULT_TIMEOUT_MS), parsePositiveInt),
-        waitFor: parseWithCliError(parsed.values['wait-for'] ?? 'load', parseWaitFor),
-        hideSelectors,
-        pageGapSeconds,
-        debugFramesDir: parsed.values['debug-frames-dir']
-            ? resolveOutPath(parsed.values['debug-frames-dir'])
-            : undefined,
-        force: parsed.values.force === true,
-    };
 }
-function toNonEmptyArray(items) {
-    if (items.length === 0) {
-        throw new CliError('capture requires at least one URL.', true);
-    }
-    return items;
+export function parseCliArgs(argv = process.argv.slice(2)) {
+    const args = argv[0] === 'capture' ? argv.slice(1) : argv;
+    return parseCaptureArgs(args);
 }
 export function formatUsage() {
     return [
-        `rollberry v${VERSION} — Capture smooth scroll videos from web pages`,
+        `rollberry v${VERSION} — Capture and render web pages into video`,
         '',
         'Usage:',
         '  rollberry capture <url...> [options]',
+        '  rollberry render <project.json> [options]',
         '  rollberry --help | -h',
         '  rollberry --version | -V',
         '',
-        'Options:',
+        'Capture Options:',
         '  --out <file>                Output MP4 path (default: ./rollberry.mp4)',
         '  --viewport <WxH>           Viewport size (default: 1440x900)',
         `  --fps <n>                  Frames per second (default: 60, max: ${MAX_FPS})`,
@@ -167,13 +79,17 @@ export function formatUsage() {
         '  --manifest <file>          Manifest JSON path (default: <out>.manifest.json)',
         '  --log-file <file>          Log JSONL path (default: <out>.log.jsonl)',
         '',
+        'Render Options:',
+        '  --output <name>            Render only the named output (repeatable)',
+        '  --force                    Overwrite configured output files',
+        '',
         'Examples:',
         '  rollberry capture http://localhost:3000',
         '  rollberry capture https://example.com --out demo.mp4 --viewport 1920x1080',
-        '  rollberry capture https://example.com --duration 10 --fps 30 --force',
+        '  rollberry render ./rollberry.project.json --output mobile',
     ].join('\n');
 }
-function parseWithCliError(rawValue, parser) {
+export function parseWithCliError(rawValue, parser) {
     try {
         return parser(rawValue);
     }
@@ -184,17 +100,17 @@ function parseWithCliError(rawValue, parser) {
         throw new CliError(error instanceof Error ? error.message : 'Failed to parse arguments.');
     }
 }
-function resolveOutPath(path) {
+export function resolveOutPath(path) {
     return resolve(process.cwd(), path);
 }
-function deriveSidecarPath(path, suffix) {
+export function deriveSidecarPath(path, suffix) {
     const extension = /\.([^.]+)$/u.exec(path);
     if (!extension) {
         return `${path}${suffix}`;
     }
     return path.slice(0, -extension[0].length) + suffix;
 }
-function parseViewport(rawViewport) {
+export function parseViewport(rawViewport) {
     const match = /^(?<width>\d+)x(?<height>\d+)$/u.exec(rawViewport);
     if (!match?.groups) {
         throw new Error(`--viewport must be in "WxH" format (e.g. "1440x900"): ${rawViewport}`);
@@ -206,34 +122,34 @@ function parseViewport(rawViewport) {
     }
     return { width, height };
 }
-function parsePositiveInt(rawValue) {
+export function parsePositiveInt(rawValue) {
     const value = Number(rawValue);
     if (!Number.isInteger(value) || value <= 0) {
         throw new Error(`Expected a positive integer (e.g. "60"): ${rawValue}`);
     }
     return value;
 }
-function parsePositiveNumber(rawValue) {
+export function parsePositiveNumber(rawValue) {
     const value = Number(rawValue);
     if (!Number.isFinite(value) || value <= 0) {
         throw new Error(`Expected a positive number (e.g. "5.0"): ${rawValue}`);
     }
     return value;
 }
-function parseNonNegativeNumber(rawValue) {
+export function parseNonNegativeNumber(rawValue) {
     const value = Number(rawValue);
     if (!Number.isFinite(value) || value < 0) {
         throw new Error(`Expected a non-negative number (e.g. "0" or "1.5"): ${rawValue}`);
     }
     return value;
 }
-function parseMotion(rawMotion) {
+export function parseMotion(rawMotion) {
     if (rawMotion === 'ease-in-out-sine' || rawMotion === 'linear') {
         return rawMotion;
     }
     throw new Error(`--motion must be "ease-in-out-sine" or "linear": ${rawMotion}`);
 }
-function parseWaitFor(rawWaitFor) {
+export function parseWaitFor(rawWaitFor) {
     if (rawWaitFor === 'load') {
         return { kind: 'load' };
     }
@@ -255,3 +171,155 @@ function parseWaitFor(rawWaitFor) {
     }
     throw new Error(`--wait-for must be "load", "selector:<css>", or "ms:<n>": ${rawWaitFor}`);
 }
+function parseCaptureArgs(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        throw new HelpRequest(formatUsage());
+    }
+    const parsed = parseArgs({
+        args,
+        allowPositionals: true,
+        options: {
+            out: {
+                type: 'string',
+            },
+            viewport: {
+                type: 'string',
+            },
+            fps: {
+                type: 'string',
+            },
+            duration: {
+                type: 'string',
+            },
+            motion: {
+                type: 'string',
+            },
+            timeout: {
+                type: 'string',
+            },
+            'wait-for': {
+                type: 'string',
+            },
+            'hide-selector': {
+                type: 'string',
+                multiple: true,
+            },
+            'debug-frames-dir': {
+                type: 'string',
+            },
+            'page-gap': {
+                type: 'string',
+            },
+            manifest: {
+                type: 'string',
+            },
+            'log-file': {
+                type: 'string',
+            },
+            force: {
+                type: 'boolean',
+            },
+        },
+        strict: true,
+    });
+    if (parsed.positionals.length === 0) {
+        throw new CliError('capture requires at least one URL.', true);
+    }
+    const urls = parsed.positionals.map((raw) => parseWithCliError(raw, parseCaptureUrl));
+    const durationOption = parsed.values.duration ?? DEFAULT_DURATION;
+    if (durationOption !== 'auto' && Number.isNaN(Number(durationOption))) {
+        throw new CliError(`--duration must be "auto" or a positive number (e.g. --duration 5): ${durationOption}`);
+    }
+    const outPath = resolveOutPath(parsed.values.out ?? DEFAULT_OUT_FILE);
+    const pageGapSeconds = parseWithCliError(parsed.values['page-gap'] ?? '0', parseNonNegativeNumber);
+    const hideSelectors = parsed.values['hide-selector'] ?? [];
+    for (const selector of hideSelectors) {
+        parseWithCliError(selector, validateHideSelector);
+    }
+    const fps = parseWithCliError(parsed.values.fps ?? String(DEFAULT_FPS), parsePositiveInt);
+    if (fps > MAX_FPS) {
+        throw new CliError(`--fps must be at most ${MAX_FPS}: ${fps}`);
+    }
+    return {
+        urls: toNonEmptyArray(urls),
+        outPath,
+        manifestPath: parsed.values.manifest
+            ? resolveOutPath(parsed.values.manifest)
+            : deriveSidecarPath(outPath, '.manifest.json'),
+        logFilePath: parsed.values['log-file']
+            ? resolveOutPath(parsed.values['log-file'])
+            : deriveSidecarPath(outPath, '.log.jsonl'),
+        viewport: parseWithCliError(parsed.values.viewport ?? DEFAULT_VIEWPORT, parseViewport),
+        fps,
+        duration: durationOption === 'auto'
+            ? 'auto'
+            : parseWithCliError(durationOption, parsePositiveNumber),
+        motion: parseWithCliError(parsed.values.motion ?? DEFAULT_MOTION, parseMotion),
+        timeoutMs: parseWithCliError(parsed.values.timeout ?? String(DEFAULT_TIMEOUT_MS), parsePositiveInt),
+        waitFor: parseWithCliError(parsed.values['wait-for'] ?? 'load', parseWaitFor),
+        hideSelectors,
+        pageGapSeconds,
+        debugFramesDir: parsed.values['debug-frames-dir']
+            ? resolveOutPath(parsed.values['debug-frames-dir'])
+            : undefined,
+        force: parsed.values.force === true,
+    };
+}
+function parseRenderArgs(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        throw new HelpRequest(formatUsage());
+    }
+    const parsed = parseArgs({
+        args,
+        allowPositionals: true,
+        options: {
+            output: {
+                type: 'string',
+                multiple: true,
+            },
+            force: {
+                type: 'boolean',
+            },
+        },
+        strict: true,
+    });
+    if (parsed.positionals.length === 0) {
+        throw new CliError('render requires a project JSON path.', true);
+    }
+    if (parsed.positionals.length > 1) {
+        throw new CliError(`render accepts exactly one project JSON path: ${parsed.positionals.slice(1).join(', ')}`, true);
+    }
+    return {
+        projectPath: resolveOutPath(parsed.positionals[0]),
+        outputNames: parsed.values.output ?? [],
+        force: parsed.values.force === true,
+    };
+}
+function toNonEmptyArray(items) {
+    if (items.length === 0) {
+        throw new CliError('capture requires at least one URL.', true);
+    }
+    return items;
+}
+function createMissingSubcommandError() {
+    return new CliError([
+        'A subcommand is required.',
+        '',
+        'Available commands:',
+        '  capture    Capture a scroll video from one or more URLs',
+        '  render     Render a project JSON file into one or more videos',
+        '',
+        'Run rollberry --help for more information.',
+    ].join('\n'));
+}
+function createUnknownSubcommandError(command) {
+    return new CliError([
+        `Unknown subcommand: ${command}`,
+        '',
+        'Available commands:',
+        '  capture    Capture a scroll video from one or more URLs',
+        '  render     Render a project JSON file into one or more videos',
+        '',
+        'Run rollberry --help for more information.',
+    ].join('\n'));
+}

package/dist/project.d.ts

@@ -0,0 +1,27 @@
+import type { CaptureAudioTrack, CaptureScene, CaptureSubtitleTrack, CaptureTransition, FinalVideoEncodingSettings, IntermediateArtifactProfile, NonEmptyArray, OutputFormat, Viewport } from './capture/types.js';
+import { type RenderCliOptions } from './options.js';
+export interface ResolvedRenderOutput {
+    name: string;
+    outPath: string;
+    format: OutputFormat;
+    manifestPath: string;
+    logFilePath: string;
+    viewport: Viewport;
+    fps: number;
+    force: boolean;
+    audio?: CaptureAudioTrack;
+    subtitles?: CaptureSubtitleTrack;
+    transition?: CaptureTransition;
+    intermediateArtifact: IntermediateArtifactProfile;
+    finalVideo: FinalVideoEncodingSettings;
+    debugFramesDir?: string;
+}
+export interface ResolvedRenderProject {
+    projectPath: string;
+    projectName: string;
+    summaryManifestPath: string;
+    timeoutMs: number;
+    scenes: NonEmptyArray<CaptureScene>;
+    outputs: NonEmptyArray<ResolvedRenderOutput>;
+}
+export declare function loadRenderProject(options: RenderCliOptions): Promise<ResolvedRenderProject>;