🎥 Make videos programmatically with React
import type {IncomingMessage} from 'node:http';
import http from 'node:http';
import type {
BundlerOverrideFn,
RspackOverrideFn,
WebpackOverrideFn,
} from '@remotion/bundler';
import {
BundlerInternals,
WatchIgnoreNextChangePlugin,
webpack,
} 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 {detectRemotionServer} from '../detect-remotion-server';
import {handleRoutes} from '../routes';
import type {QueueMethods} from './api-types';
import {wdm} from './dev-middleware';
import {setupWebpackHmr} from './hot-middleware';
import type {LiveEventsServer} from './live-events';
import {makeLiveEventsRouter} from './live-events';
import {clearNodePathCache} from './node-path-cache';
import {getRedoStack, getUndoStack} from './undo-stack';
import {setWatchIgnoreNextChangePlugin} from './watch-ignore-next-change';
export type StartServerResult =
| {
type: 'started';
port: number;
liveEventsServer: LiveEventsServer;
close: () => Promise<void>;
}
| {
type: 'already-running';
port: number;
};
export const startServer = async (options: {
entry: string;
userDefinedComponent: string;
bundlerOverride: BundlerOverrideFn;
rspackOverride: RspackOverrideFn;
webpackOverride: WebpackOverrideFn;
getCurrentInputProps: () => object;
getEnvVariables: () => Record<string, string>;
port: number | null;
remotionRoot: string;
publicDir: string;
poll: number | null;
staticHash: string;
staticHashPrefix: string;
outputHash: string;
outputHashPrefix: string;
logLevel: LogLevel;
getRenderQueue: () => RenderJob[];
getRenderDefaults: () => RenderDefaults;
getNumberOfAudioTags: () => number;
queueMethods: QueueMethods;
gitSource: GitSource | null;
binariesDirectory: string | null;
forceIPv4: boolean;
getAudioLatencyHint: () => AudioContextLatencyCategory | null;
getExperimentalKeepAudioContextAlive: () => boolean;
getPreviewSampleRate: () => number | null;
enableCrossSiteIsolation: boolean;
forceNew: boolean;
rspack: boolean;
getStudioRuntimeConfig: () => StudioRuntimeConfig;
getDefaultCodingAgent: () => DefaultCodingAgent | null;
getDefaultEditor: () => DefaultEditor | null;
configFile: string | null;
}): Promise<StartServerResult> => {
const desiredPort =
options?.port ??
(process.env.PORT ? Number(process.env.PORT) : undefined) ??
undefined;
const portConfig = RenderInternals.getPortConfig(options.forceIPv4);
const onPortUnavailable = async (
port: number,
): Promise<'continue' | 'stop'> => {
if (!options.forceNew) {
const detection = await detectRemotionServer({
port,
cwd: options.remotionRoot,
hostname: portConfig.hostsToTry[0],
});
if (detection.type === 'match') {
return 'stop';
}
}
RenderInternals.Log.info(
{indent: false, logLevel: options.logLevel},
RenderInternals.chalk.gray(`Port ${port} is busy, trying another.`),
);
return 'continue';
};
let portSelection = await RenderInternals.getDesiredPort({
desiredPort,
from: 3000,
to: 3100,
hostsToTry: portConfig.hostsToTry,
onPortUnavailable,
});
if (portSelection.didUsePort) {
portSelection.unlockPort();
return {
type: 'already-running' as const,
port: portSelection.port,
};
}
const handleRequestBeforeReady: http.RequestListener = (
_request,
response,
) => {
response.writeHead(503);
response.end('Studio is starting...');
};
const server = http.createServer(handleRequestBeforeReady);
const maxTries = 5;
let selectedPort: number | null = null;
for (let i = 0; i < maxTries; i++) {
try {
const {port, unlockPort} = portSelection;
selectedPort = await new Promise<number>((resolve, reject) => {
RenderInternals.Log.verbose(
{indent: false, logLevel: options.logLevel},
`Binding server to host ${portConfig.host}, port ${port}`,
);
const onListening = () => {
server.off('error', onError);
unlockPort();
resolve(port);
};
const onError = (error: Error) => {
server.off('listening', onListening);
reject(error);
};
server.once('listening', onListening);
server.once('error', onError);
server.listen({
port,
host: portConfig.host,
});
});
break;
} catch (err) {
if (!(err instanceof Error)) {
portSelection.unlockPort();
throw err;
}
const codedError = err as Error & {code: string; port: number};
if (codedError.code === 'EADDRINUSE') {
portSelection.unlockPort();
RenderInternals.Log.error(
{indent: false, logLevel: options.logLevel},
`Port ${codedError.port} is already in use. Trying another port...`,
);
if (i === maxTries - 1) {
break;
}
portSelection = await RenderInternals.getDesiredPort({
desiredPort,
from: 3000,
to: 3100,
hostsToTry: portConfig.hostsToTry,
onPortUnavailable,
});
if (portSelection.didUsePort) {
portSelection.unlockPort();
return {
type: 'already-running' as const,
port: portSelection.port,
};
}
} else {
portSelection.unlockPort();
throw err;
}
}
}
if (selectedPort === null) {
throw new Error(`Tried ${maxTries} times to find a free port. Giving up.`);
}
let compiler: webpack.Compiler | null = null;
try {
const watchIgnorePlugin = new WatchIgnoreNextChangePlugin((...args) => {
RenderInternals.Log.trace(
{indent: false, logLevel: options.logLevel},
...args,
);
});
const configArgs = {
entry: options.entry,
userDefinedComponent: options.userDefinedComponent,
outDir: null,
environment: 'development' as const,
bundlerOverride: options.bundlerOverride,
rspackOverride: options.rspackOverride,
webpackOverride: options?.webpackOverride,
remotionRoot: options.remotionRoot,
poll: options.poll,
extraPlugins: [watchIgnorePlugin],
};
if (options.rspack) {
const [, rspackConf] = await BundlerInternals.rspackConfig(configArgs);
compiler = BundlerInternals.createRspackCompiler(
rspackConf,
) as unknown as webpack.Compiler;
} else {
const [, webpackConf] = await BundlerInternals.webpackConfig(configArgs);
compiler = webpack(webpackConf);
}
setWatchIgnoreNextChangePlugin(watchIgnorePlugin);
const wdmMiddleware = wdm(compiler, options.logLevel);
const invalidateBundle = () => {
return new Promise<void>((resolve, reject) => {
const watching = compiler?.watching;
if (!watching) {
reject(new Error('The Studio bundle is not being watched.'));
return;
}
watching.invalidate((error) => {
if (error) {
reject(error);
return;
}
resolve();
});
});
};
const liveEventsServer = makeLiveEventsRouter(options.logLevel, () => {
const undoStack = getUndoStack();
const redoStack = getRedoStack();
return {
undoFile:
undoStack.length > 0
? undoStack[undoStack.length - 1].filePath
: null,
redoFile:
redoStack.length > 0
? redoStack[redoStack.length - 1].filePath
: null,
};
});
setupWebpackHmr(compiler, options.logLevel, liveEventsServer);
compiler.hooks.done.tap('remotion-node-path-cache', () => {
clearNodePathCache();
});
server.off('request', handleRequestBeforeReady);
server.on('request', (request, response) => {
if (options.enableCrossSiteIsolation) {
response.setHeader('Cross-Origin-Opener-Policy', 'same-origin');
response.setHeader('Cross-Origin-Embedder-Policy', 'credentialless');
}
new Promise<void>((resolve) => {
wdmMiddleware(request as IncomingMessage, response, () => {
resolve();
});
})
.then(() => {
return handleRoutes({
staticHash: options.staticHash,
staticHashPrefix: options.staticHashPrefix,
outputHash: options.outputHash,
outputHashPrefix: options.outputHashPrefix,
request: request as IncomingMessage,
response,
liveEventsServer,
getCurrentInputProps: options.getCurrentInputProps,
getEnvVariables: options.getEnvVariables,
remotionRoot: options.remotionRoot,
entryPoint: options.userDefinedComponent,
publicDir: options.publicDir,
logLevel: options.logLevel,
getRenderQueue: options.getRenderQueue,
getRenderDefaults: options.getRenderDefaults,
getNumberOfAudioTags: options.getNumberOfAudioTags,
queueMethods: options.queueMethods,
gitSource: options.gitSource,
binariesDirectory: options.binariesDirectory,
getAudioLatencyHint: options.getAudioLatencyHint,
getExperimentalKeepAudioContextAlive:
options.getExperimentalKeepAudioContextAlive,
getPreviewSampleRate: options.getPreviewSampleRate,
enableCrossSiteIsolation: options.enableCrossSiteIsolation,
getStudioRuntimeConfig: options.getStudioRuntimeConfig,
getDefaultCodingAgent: options.getDefaultCodingAgent,
getDefaultEditor: options.getDefaultEditor,
configFile: options.configFile,
invalidateBundle,
});
})
.catch((err) => {
RenderInternals.Log.error(
{indent: false, logLevel: options.logLevel},
`Error while calling ${request.url}`,
err,
);
if (!response.headersSent) {
response.setHeader('content-type', 'application/json');
response.writeHead(500);
}
if (!response.writableEnded) {
response.end(
JSON.stringify({
err: (err as Error).message,
}),
);
}
});
});
const initializedCompiler = compiler;
return {
type: 'started' as const,
port: selectedPort,
liveEventsServer,
close: async () => {
server.closeAllConnections();
await Promise.all([
new Promise<void>((resolve) => {
server.close(() => {
resolve();
});
}),
new Promise<void>((resolve) => {
initializedCompiler.close(() => {
resolve();
});
}),
]);
},
};
} catch (error) {
server.closeAllConnections();
await Promise.all([
new Promise<void>((resolve) => {
server.close(() => resolve());
}),
compiler
? new Promise<void>((resolve) => {
compiler?.close(() => resolve());
})
: Promise.resolve(),
]);
throw error;
}
};