@remotion/studio-server 4.0.502 → 4.0.504

package/dist/preview-server/routes/open-in-editor.js

@@ -5,28 +5,58 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.openInEditorHandler = exports.getEditorName = void 0;
 const node_path_1 = __importDefault(require("node:path"));
+const renderer_1 = require("@remotion/renderer");
+const custom_editor_1 = require("../../helpers/custom-editor");
 const open_in_editor_1 = require("../../helpers/open-in-editor");
-const editorGuess = (0, open_in_editor_1.guessEditor)();
-const getEditorName = async () => {
-    const [edit] = await editorGuess;
-    return (0, open_in_editor_1.getDisplayNameForEditor)(edit ? edit.command : null);
+const resolve_editor_1 = require("../../helpers/resolve-editor");
+const getEditorName = async ({ getDefaultEditor, logLevel, }) => {
+    var _a;
+    const editor = await (0, resolve_editor_1.resolveEditor)({
+        defaultEditor: getDefaultEditor(),
+        logLevel,
+        preferredEditor: null,
+    });
+    return (_a = editor === null || editor === void 0 ? void 0 : editor.name) !== null && _a !== void 0 ? _a : null;
 };
 exports.getEditorName = getEditorName;
-const openInEditorHandler = async ({ input, remotionRoot, logLevel }) => {
+const openInEditorHandler = async ({ input, remotionRoot, logLevel, getDefaultEditor }) => {
     try {
         if (!('stack' in input)) {
             throw new TypeError('Need to pass stack');
         }
         const { stack } = input;
-        const guess = await editorGuess;
-        const didOpen = await (0, open_in_editor_1.launchEditor)({
-            colNumber: stack.originalColumnNumber,
-            editor: guess[0],
-            fileName: node_path_1.default.resolve(remotionRoot, stack.originalFileName),
-            lineNumber: stack.originalLineNumber,
-            vsCodeNewWindow: false,
+        if (input.editorId !== null &&
+            input.editorId !== 'custom' &&
+            !renderer_1.defaultEditorIds.includes(input.editorId)) {
+            return { success: false };
+        }
+        const editor = await (0, resolve_editor_1.resolveEditor)({
+            defaultEditor: getDefaultEditor(),
             logLevel,
+            preferredEditor: input.editorId,
         });
+        if (!editor) {
+            return { success: false };
+        }
+        const fileName = node_path_1.default.resolve(remotionRoot, stack.originalFileName);
+        const didOpen = editor.type === 'custom'
+            ? await (0, custom_editor_1.launchCustomEditor)({
+                editor: editor.editor,
+                resolvedExecutable: editor,
+                targetPath: fileName,
+                lineNumber: stack.originalLineNumber,
+                columnNumber: stack.originalColumnNumber,
+                logLevel,
+                spawnProcess: null,
+            })
+            : await (0, open_in_editor_1.launchEditor)({
+                colNumber: stack.originalColumnNumber,
+                editor,
+                fileName,
+                lineNumber: stack.originalLineNumber,
+                vsCodeNewWindow: false,
+                logLevel,
+            });
         return {
             success: didOpen,
         };

package/dist/preview-server/routes/prepare-element-install.d.ts

@@ -0,0 +1,3 @@
+import type { PrepareElementInstallRequest, PrepareElementInstallResponse } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
+export declare const prepareElementInstallHandler: ApiHandler<PrepareElementInstallRequest, PrepareElementInstallResponse>;

package/dist/preview-server/routes/prepare-element-install.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareElementInstallHandler = void 0;
+const element_install_plan_1 = require("./element-install-plan");
+const source_file_write_queue_1 = require("./source-file-write-queue");
+const prepareElementInstallHandler = ({ input, remotionRoot }) => (0, source_file_write_queue_1.withSourceFileWriteQueue)(async () => {
+    try {
+        const plan = await (0, element_install_plan_1.getElementInstallPlan)({ ...input, remotionRoot });
+        return {
+            success: true,
+            plan: {
+                expectedFileState: plan.expectedFileState,
+                filePath: plan.filePath,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            reason: error.message,
+            stack: error.stack,
+        };
+    }
+});
+exports.prepareElementInstallHandler = prepareElementInstallHandler;

package/dist/preview-server/routes/safe-element-install-path.d.ts

@@ -0,0 +1,9 @@
+export declare const getSafeElementInstallPaths: ({ compositionFileName, elementFileName, remotionRoot, }: {
+    compositionFileName: string;
+    elementFileName: string;
+    remotionRoot: string;
+}) => Promise<{
+    compositionFileName: string;
+    elementFileName: string;
+    remotionRoot: string;
+}>;

package/dist/preview-server/routes/safe-element-install-path.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSafeElementInstallPaths = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const isInside = ({ child, parent }) => {
+    const relative = node_path_1.default.relative(parent, child);
+    return (relative === '' ||
+        (!relative.startsWith('..') && !node_path_1.default.isAbsolute(relative)));
+};
+const assertInsideProject = ({ fileName, remotionRoot, }) => {
+    if (!isInside({ child: fileName, parent: remotionRoot })) {
+        throw new Error('Element installation must stay inside the Remotion project');
+    }
+};
+const getCanonicalProjectRoot = async (remotionRoot) => {
+    return (0, promises_1.realpath)(remotionRoot);
+};
+const getSafeElementInstallPaths = async ({ compositionFileName, elementFileName, remotionRoot, }) => {
+    const canonicalRoot = await getCanonicalProjectRoot(remotionRoot);
+    const canonicalCompositionFile = await (0, promises_1.realpath)(compositionFileName);
+    assertInsideProject({
+        fileName: canonicalCompositionFile,
+        remotionRoot: canonicalRoot,
+    });
+    // The Element directory already exists because it is the composition file's
+    // directory. Resolving it before appending the file name prevents writes
+    // through a directory symlink that leaves the project.
+    const canonicalElementDirectory = await (0, promises_1.realpath)(node_path_1.default.dirname(elementFileName));
+    assertInsideProject({
+        fileName: canonicalElementDirectory,
+        remotionRoot: canonicalRoot,
+    });
+    const canonicalElementFile = node_path_1.default.join(canonicalElementDirectory, node_path_1.default.basename(elementFileName));
+    try {
+        const elementStats = await (0, promises_1.lstat)(canonicalElementFile);
+        if (elementStats.isSymbolicLink()) {
+            throw new Error('Element source file must not be a symbolic link');
+        }
+        if (!elementStats.isFile()) {
+            throw new Error('Element source path must be a file');
+        }
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    return {
+        compositionFileName: canonicalCompositionFile,
+        elementFileName: canonicalElementFile,
+        remotionRoot: canonicalRoot,
+    };
+};
+exports.getSafeElementInstallPaths = getSafeElementInstallPaths;

package/dist/preview-server/routes/save-props-mutex.d.ts

@@ -0,0 +1 @@
+export declare const withSavePropsLock: <T>(fn: () => Promise<T>) => Promise<T>;

package/dist/preview-server/routes/save-props-mutex.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withSavePropsLock = void 0;
+let chain = Promise.resolve();
+const withSavePropsLock = (fn) => {
+    const run = () => fn();
+    const next = chain.then(run, run);
+    chain = next.then(() => undefined, () => undefined);
+    return next;
+};
+exports.withSavePropsLock = withSavePropsLock;

package/dist/preview-server/routes/update-public-license.d.ts

@@ -4,4 +4,8 @@ export declare const updatePublicLicenseInConfig: ({ configContents, publicLicen
     configContents: string;
     publicLicenseKey: string;
 }) => string;
+export declare const setPublicLicenseKeyInConfigFile: ({ configFile, publicLicenseKey, }: {
+    readonly configFile: string;
+    readonly publicLicenseKey: string;
+}) => void;
 export declare const updatePublicLicenseHandler: ApiHandler<UpdatePublicLicenseRequest, UpdatePublicLicenseResponse>;

package/dist/preview-server/routes/update-public-license.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updatePublicLicenseHandler = exports.updatePublicLicenseInConfig = void 0;
+exports.updatePublicLicenseHandler = exports.setPublicLicenseKeyInConfigFile = exports.updatePublicLicenseInConfig = void 0;
 const node_fs_1 = require("node:fs");
 const recast = __importStar(require("recast"));
 const parse_ast_1 = require("../../codemods/parse-ast");
@@ -70,6 +70,11 @@ const updatePublicLicenseInConfig = ({ configContents, publicLicenseKey, }) => {
     return `${configWithoutExistingCalls}${separator}Config.setPublicLicenseKey('${escapedPublicLicenseKey}');\n`;
 };
 exports.updatePublicLicenseInConfig = updatePublicLicenseInConfig;
+const setPublicLicenseKeyInConfigFile = ({ configFile, publicLicenseKey, }) => {
+    const configContents = (0, node_fs_1.readFileSync)(configFile, 'utf8');
+    (0, file_watcher_1.writeFileAndNotifyFileWatchers)(configFile, (0, exports.updatePublicLicenseInConfig)({ configContents, publicLicenseKey }), undefined);
+};
+exports.setPublicLicenseKeyInConfigFile = setPublicLicenseKeyInConfigFile;
 const updatePublicLicenseHandler = ({ input, configFile }) => {
     if (configFile === null || configFile === undefined) {
         return Promise.resolve({
@@ -83,11 +88,10 @@ const updatePublicLicenseHandler = ({ input, configFile }) => {
             reason: 'The public license key must not be empty.',
         });
     }
-    const configContents = (0, node_fs_1.readFileSync)(configFile, 'utf8');
-    (0, file_watcher_1.writeFileAndNotifyFileWatchers)(configFile, (0, exports.updatePublicLicenseInConfig)({
-        configContents,
+    (0, exports.setPublicLicenseKeyInConfigFile)({
+        configFile,
         publicLicenseKey: input.publicLicenseKey,
-    }), undefined);
+    });
     return Promise.resolve({ success: true });
 };
 exports.updatePublicLicenseHandler = updatePublicLicenseHandler;

package/dist/preview-server/start-server.d.ts

@@ -1,4 +1,5 @@
 import type { BundlerOverrideFn, RspackOverrideFn, WebpackOverrideFn } from '@remotion/bundler';
+import type { DefaultEditor } from '@remotion/renderer';
 import type { GitSource, RenderDefaults, RenderJob, StudioRuntimeConfig } from '@remotion/studio-shared';
 import type { QueueMethods } from './api-types';
 import type { LiveEventsServer } from './live-events';
@@ -41,5 +42,6 @@ export declare const startServer: (options: {
     forceNew: boolean;
     rspack: boolean;
     getStudioRuntimeConfig: () => StudioRuntimeConfig;
+    getDefaultEditor: () => DefaultEditor | null;
     configFile: string | null;
 }) => Promise<StartServerResult>;

package/dist/preview-server/start-server.js

@@ -102,6 +102,7 @@ const startServer = async (options) => {
                 getPreviewSampleRate: options.getPreviewSampleRate,
                 enableCrossSiteIsolation: options.enableCrossSiteIsolation,
                 getStudioRuntimeConfig: options.getStudioRuntimeConfig,
+                getDefaultEditor: options.getDefaultEditor,
                 configFile: options.configFile,
             });
         })

package/dist/preview-server/studio-protocol/handle-discovery.js

@@ -10,7 +10,7 @@ const version_1 = require("remotion/version");
 const element_install_state_1 = require("../element-install-state");
 const origin_policy_1 = require("./origin-policy");
 const protocol_response_1 = require("./protocol-response");
-const ELEMENT_INSTALL_FOCUS_MAX_AGE = 5 * 60 * 1000;
+const STUDIO_PROTOCOL_FOCUS_MAX_AGE = 5 * 60 * 1000;
 exports.ELEMENT_INSTALL_TARGET_RESPONSE_WAIT = 250;
 const requestInstallTarget = ({ liveEventsServer, }) => {
     const requestId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
@@ -20,29 +20,32 @@ const requestInstallTarget = ({ liveEventsServer, }) => {
     });
     return requestId;
 };
-const getLiveInstallableTarget = (requestId) => {
+const getLiveStudioTarget = (requestId) => {
     const target = (0, element_install_state_1.getElementInstallTarget)(requestId);
     const now = Date.now();
     if (target === null ||
         now - target.updatedAt >= element_install_state_1.ELEMENT_INSTALL_TARGET_MAX_AGE ||
         target.lastFocusedAt === null ||
-        now - target.lastFocusedAt >= ELEMENT_INSTALL_FOCUS_MAX_AGE ||
-        !target.canInstall ||
-        target.readOnly ||
-        target.compositionFile === null ||
-        target.compositionId === null) {
+        now - target.lastFocusedAt >= STUDIO_PROTOCOL_FOCUS_MAX_AGE ||
+        target.readOnly) {
         return null;
     }
     return target;
 };
+const isInstallableTarget = (target) => target !== null &&
+    target.canInstall &&
+    target.compositionFile !== null &&
+    target.compositionId !== null &&
+    target.lastFocusedAt !== null;
 const getProject = ({ gitSource, remotionRoot, }) => (0, studio_shared_1.getProjectName)({
     basename: node_path_1.default.basename,
     gitSource,
     resolvedRemotionRoot: remotionRoot,
 });
 const handleStudioProtocolDiscovery = ({ gitSource, liveEventsServer, remotionRoot, request, response, }) => {
-    (0, origin_policy_1.setStudioProtocolCorsHeaders)({ request, response });
-    if (!(0, origin_policy_1.isAllowedStudioProtocolOrigin)(request.headers.origin)) {
+    (0, origin_policy_1.setStudioProtocolCorsHeaders)({ licenseKey: false, request, response });
+    const requestOrigin = (0, origin_policy_1.getAllowedStudioProtocolOrigin)(request.headers.origin);
+    if (requestOrigin === null) {
         (0, protocol_response_1.writeStudioProtocolError)({
             code: 'unsupported-origin',
             message: 'Origin not allowed',
@@ -64,8 +67,25 @@ const handleStudioProtocolDiscovery = ({ gitSource, liveEventsServer, remotionRo
     return new Promise((resolve) => {
         setTimeout(() => {
             const now = Date.now();
-            const target = getLiveInstallableTarget(requestId);
-            const issued = target === null ? null : (0, element_install_state_1.issueStudioProtocolTarget)({ now, target });
+            const target = getLiveStudioTarget(requestId);
+            const installTarget = isInstallableTarget(target) ? target : null;
+            const issuedInstallTarget = installTarget === null
+                ? null
+                : (0, element_install_state_1.issueStudioProtocolTarget)({
+                    now,
+                    origin: requestOrigin,
+                    purpose: 'install-element',
+                    target: installTarget,
+                });
+            const licenseKeyOrigin = (0, origin_policy_1.getAllowedLicenseKeyOrigin)(request.headers.origin);
+            const issuedLicenseKeyTarget = target === null || licenseKeyOrigin === null
+                ? null
+                : (0, element_install_state_1.issueStudioProtocolTarget)({
+                    now,
+                    origin: licenseKeyOrigin,
+                    purpose: 'set-license-key',
+                    target,
+                });
             response.writeHead(200, {
                 'Cache-Control': 'no-store',
                 'Content-Type': 'application/json',
@@ -74,23 +94,34 @@ const handleStudioProtocolDiscovery = ({ gitSource, liveEventsServer, remotionRo
                 protocol: 'remotion-studio-protocol',
                 protocolVersion: 1,
                 studioVersion: version_1.VERSION,
-                capabilities: {
-                    install: [
-                        {
-                            payloadType: 'remotion-element',
-                            payloadVersions: [1],
-                        },
-                    ],
-                },
                 projectName: getProject({ gitSource, remotionRoot }),
-                installTarget: issued === null || target === null
-                    ? null
-                    : {
-                        id: issued.id,
-                        expiresAt: issued.expiresAt,
-                        compositionId: target.compositionId,
-                        lastFocusedAt: target.lastFocusedAt,
+                capabilities: [
+                    {
+                        type: 'install-element',
+                        payloadType: 'remotion-element',
+                        payloadVersions: [1],
+                        target: issuedInstallTarget === null || installTarget === null
+                            ? null
+                            : {
+                                id: issuedInstallTarget.id,
+                                expiresAt: issuedInstallTarget.expiresAt,
+                                compositionId: installTarget.compositionId,
+                                lastFocusedAt: installTarget.lastFocusedAt,
+                            },
                     },
+                    {
+                        type: 'set-license-key',
+                        target: issuedLicenseKeyTarget === null ||
+                            target === null ||
+                            target.lastFocusedAt === null
+                            ? null
+                            : {
+                                id: issuedLicenseKeyTarget.id,
+                                expiresAt: issuedLicenseKeyTarget.expiresAt,
+                                lastFocusedAt: target.lastFocusedAt,
+                            },
+                    },
+                ],
             }));
             resolve();
         }, exports.ELEMENT_INSTALL_TARGET_RESPONSE_WAIT);

package/dist/preview-server/studio-protocol/handle-install.js

@@ -8,6 +8,7 @@ const parse_body_1 = require("../parse-body");
 const origin_policy_1 = require("./origin-policy");
 const protocol_response_1 = require("./protocol-response");
 const studioProtocolInstallRequestSchema = zod_1.z.object({
+    operation: zod_1.z.literal('install-element'),
     protocol: zod_1.z.literal('remotion-studio-protocol'),
     protocolVersion: zod_1.z.literal(1),
     targetId: zod_1.z.string(),
@@ -16,7 +17,7 @@ const studioProtocolInstallRequestSchema = zod_1.z.object({
 // A valid payload may contain 250,000 JSON characters. Allow room for its
 // UTF-8 representation and the protocol envelope while keeping memory bounded.
 const MAX_STUDIO_PROTOCOL_INSTALL_BODY_SIZE = 1000000;
-const deliverElementInstall = ({ element, focusStudioTab, liveEventsServer, target, }) => {
+const deliverElementInstall = ({ element, focusStudioTab, liveEventsServer, origin, target, }) => {
     if (target.compositionFile === null || target.compositionId === null) {
         return false;
     }
@@ -27,7 +28,12 @@ const deliverElementInstall = ({ element, focusStudioTab, liveEventsServer, targ
         compositionFile: target.compositionFile,
         compositionId: target.compositionId,
         element,
+        from: null,
         position: null,
+        source: {
+            type: 'studio-protocol',
+            origin,
+        },
     };
     const delivered = liveEventsServer.sendEventToClientId(target.clientId, {
         type: 'element-install-request',
@@ -39,8 +45,9 @@ const deliverElementInstall = ({ element, focusStudioTab, liveEventsServer, targ
     return delivered;
 };
 const handleStudioProtocolInstall = async ({ focusStudioTab, liveEventsServer, request, response, }) => {
-    (0, origin_policy_1.setStudioProtocolCorsHeaders)({ request, response });
-    if (!(0, origin_policy_1.isAllowedStudioProtocolOrigin)(request.headers.origin)) {
+    (0, origin_policy_1.setStudioProtocolCorsHeaders)({ licenseKey: false, request, response });
+    const requestOrigin = (0, origin_policy_1.getAllowedStudioProtocolOrigin)(request.headers.origin);
+    if (requestOrigin === null) {
         (0, protocol_response_1.writeStudioProtocolError)({
             code: 'unsupported-origin',
             message: 'Origin not allowed',
@@ -104,6 +111,8 @@ const handleStudioProtocolInstall = async ({ focusStudioTab, liveEventsServer, r
     }
     const target = (0, element_install_state_1.consumeStudioProtocolTarget)({
         now: Date.now(),
+        origin: requestOrigin,
+        purpose: 'install-element',
         targetId: parsedRequest.data.targetId,
     });
     if (target === null) {
@@ -119,6 +128,7 @@ const handleStudioProtocolInstall = async ({ focusStudioTab, liveEventsServer, r
         element: payload.element,
         focusStudioTab,
         liveEventsServer,
+        origin: requestOrigin,
         target,
     })) {
         (0, protocol_response_1.writeStudioProtocolError)({

package/dist/preview-server/studio-protocol/handle-license-key.d.ts

@@ -0,0 +1,6 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare const handleStudioProtocolLicenseKey: ({ configFile, request, response, }: {
+    readonly configFile: string | null;
+    readonly request: IncomingMessage;
+    readonly response: ServerResponse<IncomingMessage>;
+}) => Promise<void>;

package/dist/preview-server/studio-protocol/handle-license-key.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStudioProtocolLicenseKey = void 0;
+const studio_protocol_1 = require("@remotion/studio-protocol");
+const zod_1 = require("zod");
+const element_install_state_1 = require("../element-install-state");
+const parse_body_1 = require("../parse-body");
+const update_public_license_1 = require("../routes/update-public-license");
+const origin_policy_1 = require("./origin-policy");
+const protocol_response_1 = require("./protocol-response");
+const studioProtocolLicenseKeyRequestSchema = zod_1.z.object({
+    operation: zod_1.z.literal('set-license-key'),
+    protocol: zod_1.z.literal('remotion-studio-protocol'),
+    protocolVersion: zod_1.z.literal(1),
+    targetId: zod_1.z.string().min(1),
+    licenseKey: zod_1.z.string(),
+});
+const MAX_STUDIO_PROTOCOL_LICENSE_KEY_BODY_SIZE = 4096;
+const handleStudioProtocolLicenseKey = async ({ configFile, request, response, }) => {
+    (0, origin_policy_1.setStudioProtocolCorsHeaders)({ licenseKey: true, request, response });
+    const requestOrigin = (0, origin_policy_1.getAllowedLicenseKeyOrigin)(request.headers.origin);
+    if (requestOrigin === null) {
+        (0, protocol_response_1.writeStudioProtocolError)({
+            code: 'unsupported-origin',
+            message: 'Origin not allowed',
+            response,
+            status: 403,
+        });
+        return;
+    }
+    if (request.method !== 'POST') {
+        (0, protocol_response_1.writeStudioProtocolError)({
+            code: 'method-not-allowed',
+            message: 'Use POST to set a public license key.',
+            response,
+            status: 405,
+        });
+        return;
+    }
+    let body;
+    try {
+        body = await (0, parse_body_1.parseRequestBody)(request, {
+            maxBytes: MAX_STUDIO_PROTOCOL_LICENSE_KEY_BODY_SIZE,
+        });
+    }
+    catch (error) {
+        if (error instanceof parse_body_1.RequestBodyTooLargeError) {
+            (0, protocol_response_1.writeStudioProtocolError)({
+                code: 'request-too-large',
+                message: 'The request body is too large.',
+                response,
+                status: 413,
+            });
+            return;
+        }
+        (0, protocol_response_1.writeStudioProtocolError)({
+            code: 'invalid-request',
+            message: 'The request body is not valid JSON.',
+            response,
+            status: 400,
+        });
+        return;
+    }
+    const parsedRequest = studioProtocolLicenseKeyRequestSchema.safeParse(body);
+    if (!parsedRequest.success) {
+        (0, protocol_response_1.writeStudioProtocolError)({
+            code: 'unsupported-protocol',
+            message: 'Invalid Remotion Studio Protocol request.',
+            response,
+            status: 400,
+        });
+        return;
+    }
+    if (!studio_protocol_1.StudioProtocolInternals.isValidPublicLicenseKey(parsedRequest.data.licenseKey)) {
+        (0, protocol_response_1.writeStudioProtocolError)({
+            code: 'invalid-license-key',
+            message: 'The license key is not a valid public Remotion license key.',
+            response,
+            status: 400,
+        });
+        return;
+    }
+    const target = (0, element_install_state_1.consumeStudioProtocolTarget)({
+        now: Date.now(),
+        origin: requestOrigin,
+        purpose: 'set-license-key',
+        targetId: parsedRequest.data.targetId,
+    });
+    if (target === null) {
+        (0, protocol_response_1.writeStudioProtocolError)({
+            code: 'target-expired',
+            message: 'The selected Studio target is no longer available.',
+            response,
+            status: 409,
+        });
+        return;
+    }
+    if (configFile === null) {
+        (0, protocol_response_1.writeStudioProtocolError)({
+            code: 'no-config-file',
+            message: 'The selected Studio did not load a Remotion config file.',
+            response,
+            status: 409,
+        });
+        return;
+    }
+    try {
+        (0, update_public_license_1.setPublicLicenseKeyInConfigFile)({
+            configFile,
+            publicLicenseKey: parsedRequest.data.licenseKey,
+        });
+    }
+    catch (_a) {
+        (0, protocol_response_1.writeStudioProtocolError)({
+            code: 'config-write-failed',
+            message: 'Could not update the Remotion config file.',
+            response,
+            status: 500,
+        });
+        return;
+    }
+    response.writeHead(200, { 'Content-Type': 'application/json' });
+    response.end(JSON.stringify({
+        protocol: 'remotion-studio-protocol',
+        protocolVersion: 1,
+        status: 'license-key-set',
+    }));
+};
+exports.handleStudioProtocolLicenseKey = handleStudioProtocolLicenseKey;

package/dist/preview-server/studio-protocol/origin-policy.d.ts

@@ -1,10 +1,13 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
-export declare const isAllowedStudioProtocolOrigin: (origin: string | undefined) => boolean;
-export declare const setStudioProtocolCorsHeaders: ({ request, response, }: {
+export declare const getAllowedStudioProtocolOrigin: (origin: string | undefined) => string | null;
+export declare const getAllowedLicenseKeyOrigin: (origin: string | undefined) => string | null;
+export declare const setStudioProtocolCorsHeaders: ({ licenseKey, request, response, }: {
+    readonly licenseKey: boolean;
     readonly request: IncomingMessage;
     readonly response: ServerResponse<IncomingMessage>;
 }) => void;
-export declare const handleStudioProtocolOptions: ({ request, response, }: {
+export declare const handleStudioProtocolOptions: ({ licenseKey, request, response, }: {
+    readonly licenseKey: boolean;
     readonly request: IncomingMessage;
     readonly response: ServerResponse<IncomingMessage>;
 }) => Promise<void>;