rollberry 0.1.8 → 0.2.0

package/dist/options.js

@@ -1,12 +1,14 @@
 import { resolve } from 'node:path';
 import { parseArgs } from 'node:util';
-import { parseCaptureUrl } from './capture/utils.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;
+import { MAX_FPS } from './capture/constants.js';
+import { parseCaptureUrl, validateHideSelector } from './capture/utils.js';
+import { VERSION } from './version.js';
+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) {
@@ -15,119 +17,79 @@ export class CliError extends Error {
         this.name = 'CliError';
     }
 }
-export function parseCliArgs(argv = process.argv.slice(2)) {
+export class HelpRequest extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'HelpRequest';
+    }
+}
+export class VersionRequest extends Error {
+    version = VERSION;
+    constructor() {
+        super(VERSION);
+        this.name = 'VersionRequest';
+    }
+}
+export function parseCommandArgs(argv = process.argv.slice(2)) {
     const [command, ...rest] = argv;
-    if (!command) {
-        throw new CliError('サブコマンドが必要です。', true);
+    if (command === '--help' || command === '-h') {
+        throw new HelpRequest(formatUsage());
     }
-    if (command !== 'capture') {
-        throw new CliError(`未知のサブコマンドです: ${command}`, true);
+    if (command === '--version' || command === '-V') {
+        throw new VersionRequest();
     }
-    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',
-            },
-        },
-        strict: true,
-    });
-    if (parsed.positionals.length === 0) {
-        throw new CliError('capture にはURLが必要です。', true);
+    if (!command) {
+        throw createMissingSubcommandError();
     }
-    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 は "auto" または数値で指定してください: ${durationOption}`);
+    switch (command) {
+        case 'capture':
+            return { kind: 'capture', options: parseCaptureArgs(rest) };
+        case 'render':
+            return { kind: 'render', options: parseRenderArgs(rest) };
+        default:
+            throw createUnknownSubcommandError(command);
     }
-    const outPath = resolveOutPath(parsed.values.out ?? DEFAULT_OUT_FILE);
-    const pageGapSeconds = parseWithCliError(parsed.values['page-gap'] ?? '0', parseNonNegativeNumber);
-    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: parseWithCliError(parsed.values.fps ?? String(DEFAULT_FPS), parsePositiveInt),
-        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: parsed.values['hide-selector'] ?? [],
-        pageGapSeconds,
-        debugFramesDir: parsed.values['debug-frames-dir']
-            ? resolveOutPath(parsed.values['debug-frames-dir'])
-            : undefined,
-    };
 }
-function toNonEmptyArray(items) {
-    if (items.length === 0) {
-        throw new CliError('capture には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 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)',
+        `  --fps <n>                  Frames per second (default: 60, max: ${MAX_FPS})`,
         '  --duration <seconds|auto>  Capture duration (default: auto)',
-        '  --motion <curve>           ease-in-out-sine | linear',
+        '  --motion <curve>           ease-in-out-sine | linear (default: ease-in-out-sine)',
         '  --timeout <ms>             Navigation timeout (default: 30000)',
-        '  --wait-for <mode>          load | selector:<css> | ms:<n>',
-        '  --hide-selector <css>      Hide CSS selector before capture',
+        '  --wait-for <mode>          load | selector:<css> | ms:<n> (default: load)',
+        '  --hide-selector <css>      Hide CSS selector before capture (repeatable)',
+        '  --force                    Overwrite output file if it already exists',
         '  --debug-frames-dir <dir>   Save raw PNG frames for debugging',
         '  --page-gap <seconds>       Pause between pages (default: 0)',
         '  --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 render ./rollberry.project.json --output mobile',
     ].join('\n');
 }
-function parseWithCliError(rawValue, parser) {
+export function parseWithCliError(rawValue, parser) {
     try {
         return parser(rawValue);
     }
@@ -135,66 +97,66 @@ function parseWithCliError(rawValue, parser) {
         if (error instanceof CliError) {
             throw error;
         }
-        throw new CliError(error instanceof Error ? error.message : '引数の解析に失敗しました。');
+        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 は "1440x900" の形式で指定してください: ${rawViewport}`);
+        throw new Error(`--viewport must be in "WxH" format (e.g. "1440x900"): ${rawViewport}`);
     }
     const width = Number(match.groups.width);
     const height = Number(match.groups.height);
     if (width <= 0 || height <= 0) {
-        throw new Error(`--viewport の値が不正です: ${rawViewport}`);
+        throw new Error(`--viewport dimensions must be positive (e.g. "1440x900"): ${rawViewport}`);
     }
     return { width, height };
 }
-function parsePositiveInt(rawValue) {
+export function parsePositiveInt(rawValue) {
     const value = Number(rawValue);
     if (!Number.isInteger(value) || value <= 0) {
-        throw new Error(`正の整数を指定してください: ${rawValue}`);
+        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(`正の数値を指定してください: ${rawValue}`);
+        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(`0以上の数値を指定してください: ${rawValue}`);
+        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 は ease-in-out-sine または linear です: ${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' };
     }
     if (rawWaitFor.startsWith('selector:')) {
         const selector = rawWaitFor.slice('selector:'.length).trim();
         if (!selector) {
-            throw new Error('--wait-for selector:<css> の CSS セレクタが空です。');
+            throw new Error('--wait-for selector:<css> requires a non-empty CSS selector.');
         }
         return {
             kind: 'selector',
@@ -207,5 +169,157 @@ function parseWaitFor(rawWaitFor) {
             ms: parsePositiveInt(rawWaitFor.slice('ms:'.length)),
         };
     }
-    throw new Error(`--wait-for は load / selector:<css> / ms:<n> のいずれかです: ${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>;