Skip to content

🎥 Make videos programmatically with React

7.0 KB
Raw Blame
import crypto from 'node:crypto';
import {existsSync} from 'node:fs';
import path from 'node:path';
import type {
	BundlerOverrideFn,
	RspackOverrideFn,
	WebpackOverrideFn,
} from '@remotion/bundler';
import type {
	DefaultCodingAgent,
	DefaultEditor,
	LogLevel,
} from '@remotion/renderer';
import {RenderInternals} from '@remotion/renderer';
import type {
	GitSource,
	RenderDefaults,
	RenderJob,
	StudioRuntimeConfig,
} from '@remotion/studio-shared';
import {getFileWatcherRegistry} from './file-watcher';
import {getNetworkAddress} from './get-network-address';
import {maybeOpenBrowser} from './maybe-open-browser';
import type {QueueMethods} from './preview-server/api-types';
import {noOpUntilRestart} from './preview-server/close-and-restart';
import {getAbsolutePublicDir} from './preview-server/get-absolute-public-dir';
import {
	setLiveEventsListener,
	waitForLiveEventsListener,
} from './preview-server/live-events';
import {getFiles, initPublicFolderWatch} from './preview-server/public-folder';
import {startServer} from './preview-server/start-server';
import {printServerReadyComment, setServerReadyComment} from './server-ready';
import {registerStudioShortcuts} from './studio-shortcuts';
import {watchRootFile} from './watch-root-file';

export type StartStudioResult =
	| {type: 'restarted'; port: number}
	| {type: 'already-running'}
	| {type: 'shutdown'};

export const startStudio = async ({
	browserArgs,
	browserFlag,
	shouldOpenBrowser,
	fullEntryPath,
	logLevel,
	getCurrentInputProps,
	getEnvVariables,
	desiredPort,
	remotionRoot,
	relativePublicDir,
	bundlerOverride,
	rspackOverride,
	webpackOverride,
	poll,
	getRenderDefaults,
	getRenderQueue,
	getNumberOfAudioTags,
	queueMethods,
	previewEntry,
	gitSource,
	binariesDirectory,
	forceIPv4,
	getAudioLatencyHint,
	getExperimentalKeepAudioContextAlive,
	getPreviewSampleRate,
	enableCrossSiteIsolation,
	forceNew,
	rspack,
	getStudioRuntimeConfig,
	getDefaultCodingAgent,
	getDefaultEditor,
	configFile,
}: {
	browserArgs: string;
	browserFlag: string;
	logLevel: LogLevel;
	shouldOpenBrowser: boolean;
	fullEntryPath: string;
	getCurrentInputProps: () => object;
	getEnvVariables: () => Record<string, string>;
	desiredPort: number | null;
	remotionRoot: string;
	relativePublicDir: string | null;
	bundlerOverride: BundlerOverrideFn;
	rspackOverride: RspackOverrideFn;
	webpackOverride: WebpackOverrideFn;
	poll: number | null;
	getRenderDefaults: () => RenderDefaults;
	getRenderQueue: () => RenderJob[];
	getNumberOfAudioTags: () => number;
	getAudioLatencyHint: () => AudioContextLatencyCategory | null;
	getExperimentalKeepAudioContextAlive: () => boolean;
	getPreviewSampleRate: () => number | null;
	enableCrossSiteIsolation: boolean;
	queueMethods: QueueMethods;
	previewEntry: string;
	gitSource: GitSource | null;
	binariesDirectory: string | null;
	forceIPv4: boolean;
	forceNew: boolean;
	rspack: boolean;
	getStudioRuntimeConfig: () => StudioRuntimeConfig;
	getDefaultCodingAgent: () => DefaultCodingAgent | null;
	getDefaultEditor: () => DefaultEditor | null;
	configFile: string | null;
}): Promise<StartStudioResult> => {
	try {
		if (typeof Bun === 'undefined') {
			process.title = 'node (npx remotion studio)';
		} else if (typeof Deno === 'undefined') {
			process.title = 'deno (npx remotiond studio)';
		} else {
			process.title = `bun (bunx remotionb studio)`;
		}
	} catch {}

	// Validate that the file watcher registry has been initialized
	getFileWatcherRegistry();

	watchRootFile(remotionRoot, previewEntry);
	const publicDir = getAbsolutePublicDir({
		relativePublicDir,
		remotionRoot,
	});
	const outputHashPrefix = '/outputs-';
	const outputHash = `${outputHashPrefix}${crypto.randomBytes(6).toString('hex')}`;

	// Asset URLs must survive restarts, but remain scoped to this project and folder.
	const staticHashPrefix = '/static-';
	const staticHash = `${staticHashPrefix}${crypto
		.createHash('sha256')
		.update(JSON.stringify([remotionRoot, publicDir]))
		.digest('hex')
		.slice(0, 12)}`;

	initPublicFolderWatch({
		publicDir,
		remotionRoot,
		onUpdate: () => {
			waitForLiveEventsListener().then((listener) => {
				const files = getFiles();
				listener.sendEventToClient({
					type: 'new-public-folder',
					files,
					folderExists:
						files.length > 0
							? publicDir
							: existsSync(publicDir)
								? publicDir
								: null,
				});
			});
		},
		staticHash,
	});

	const result = await startServer({
		entry: path.resolve(previewEntry),
		userDefinedComponent: fullEntryPath,
		getCurrentInputProps,
		getEnvVariables,
		port: desiredPort,
		remotionRoot,
		publicDir,
		bundlerOverride,
		rspackOverride,
		webpackOverride,
		poll,
		staticHash,
		staticHashPrefix,
		outputHash,
		outputHashPrefix,
		logLevel,
		getRenderDefaults,
		getRenderQueue,
		getNumberOfAudioTags,
		queueMethods,
		gitSource,
		binariesDirectory,
		forceIPv4,
		getAudioLatencyHint,
		getExperimentalKeepAudioContextAlive,
		getPreviewSampleRate,
		enableCrossSiteIsolation,
		forceNew,
		rspack,
		getStudioRuntimeConfig,
		getDefaultCodingAgent,
		getDefaultEditor,
		configFile,
	});

	if (result.type === 'already-running') {
		RenderInternals.Log.info(
			{indent: false, logLevel},
			`Already running at http://localhost:${result.port}`,
		);
		const res = await maybeOpenBrowser({
			browserArgs,
			browserFlag,
			shouldOpenBrowser,
			url: `http://localhost:${result.port}`,
			logLevel,
		});
		if (res.didOpenBrowser) {
			RenderInternals.Log.info(
				{indent: false, logLevel},
				'Opened browser. Pass --force-new to force a new instance.',
			);
		}

		return {type: 'already-running'};
	}

	const {port, liveEventsServer, close} = result;

	const cleanupLiveEventsListener = setLiveEventsListener(liveEventsServer);
	const networkAddress = getNetworkAddress();
	if (networkAddress) {
		setServerReadyComment(
			`Local: ${RenderInternals.chalk.underline(
				`http://localhost:${port}`,
			)}, Network: ${RenderInternals.chalk.underline(
				`http://${networkAddress}:${port}`,
			)}`,
		);
	} else {
		setServerReadyComment(`http://localhost:${port}`);
	}

	printServerReadyComment('Server ready', logLevel);
	RenderInternals.Log.info({indent: false, logLevel}, 'Building...');
	const studioUrl = `http://localhost:${port}`;
	const studioShortcuts = registerStudioShortcuts({
		browserArgs,
		browserFlag,
		url: studioUrl,
		logLevel,
		remotionRoot,
		getDefaultEditor,
		getDefaultCodingAgent,
	});

	let action: 'restart' | 'shutdown';
	try {
		await maybeOpenBrowser({
			browserArgs,
			browserFlag,
			shouldOpenBrowser,
			url: studioUrl,
			logLevel,
		});

		action = await noOpUntilRestart();
	} finally {
		studioShortcuts.cleanup();
	}

	RenderInternals.Log.info(
		{indent: false, logLevel},
		action === 'shutdown'
			? 'Shutting down Studio...'
			: 'Closing server to restart...',
	);

	await liveEventsServer.closeConnections();
	cleanupLiveEventsListener();
	await close();
	if (action === 'shutdown') {
		return {type: 'shutdown'};
	}

	RenderInternals.Log.info(
		{indent: false, logLevel},
		RenderInternals.chalk.blue('Restarting server...'),
	);

	return {type: 'restarted', port};
};