@remotion/studio-server 4.0.533 → 4.0.535

package/dist/detect-outdated-remotion-skills.d.ts

@@ -15,6 +15,10 @@ export type RemotionSkillsStatus = {
     outdatedSkillNames: RemotionSkillName[];
 };
 export declare const parseRemotionSkillVersion: (contents: string) => string | null;
+export declare const readRemotionSkill: (skillFile: string) => {
+    installed: boolean;
+    version: string | null;
+};
 export declare const getRemotionSkillsDirectories: ({ cwd, homeDirectory, }: {
     cwd: string;
     homeDirectory: string;

package/dist/detect-outdated-remotion-skills.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectOutdatedRemotionSkills = exports.getRemotionSkillsDirectories = exports.parseRemotionSkillVersion = void 0;
+exports.detectOutdatedRemotionSkills = exports.getRemotionSkillsDirectories = exports.readRemotionSkill = exports.parseRemotionSkillVersion = void 0;
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
@@ -34,10 +34,11 @@ const readRemotionSkill = (skillFile) => {
         return { installed: true, version: null };
     }
 };
+exports.readRemotionSkill = readRemotionSkill;
 const getStatusForSkillsDirectory = ({ currentVersion, scope, skillsDirectory, }) => {
     const installedSkills = new Map();
     for (const skillName of remotion_skill_names_1.remotionSkillNames) {
-        installedSkills.set(skillName, readRemotionSkill(node_path_1.default.join(skillsDirectory, skillName, 'SKILL.md')));
+        installedSkills.set(skillName, (0, exports.readRemotionSkill)(node_path_1.default.join(skillsDirectory, skillName, 'SKILL.md')));
     }
     if ([...installedSkills.values()].every((skill) => !skill.installed)) {
         return { type: 'not-installed', scope, skillsDirectory };

package/dist/file-watcher.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeFileAndNotifyFileWatchers = exports.installFileWatcher = exports.getFileWatcherRegistry = exports.setFileWatcherRegistry = exports.createFileWatcherRegistry = void 0;
 const node_fs_1 = __importStar(require("node:fs"));
+const watch_ignore_next_change_1 = require("./preview-server/watch-ignore-next-change");
 const getRegistryKey = (file, existenceOnly) => existenceOnly ? `${file}\0existence-only` : file;
 const createFileWatcherRegistry = () => {
     const sharedWatchers = new Map();
@@ -130,6 +131,7 @@ const createFileWatcherRegistry = () => {
     };
     const _writeFileAndNotifyFileWatchers = ({ file, content, originatorClientId, metadata, }) => {
         var _a;
+        (0, watch_ignore_next_change_1.prepareBundlerForFileWrite)(file);
         (0, node_fs_1.writeFileSync)(file, content);
         const shared = sharedWatchers.get(getRegistryKey(file, false));
         if (!shared) {

package/dist/helpers/app-discovery.d.ts

@@ -0,0 +1,9 @@
+import type { DefaultEditor } from '@remotion/renderer';
+import type { GetDefaultEditorInfoResponse } from '@remotion/studio-shared';
+export declare const getAppDiscovery: () => Promise<{
+    installedEditors: readonly import("./editor-registry").InstalledEditor[];
+    installedCodingAgents: readonly import("./coding-agent-registry").InstalledCodingAgent[];
+    runningEditors: readonly ("cursor" | "sublime-text" | "vscode" | "vscodium" | "webstorm" | "windsurf" | "zed")[];
+    runningCodingAgents: readonly ("claude-code" | "codex" | "copilot" | "cursor")[];
+}>;
+export declare const getEditorInfo: (configuredEditor: DefaultEditor | null) => Promise<GetDefaultEditorInfoResponse>;

package/dist/helpers/app-discovery.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEditorInfo = exports.getAppDiscovery = void 0;
+const coding_agent_registry_1 = require("./coding-agent-registry");
+const custom_editor_1 = require("./custom-editor");
+const editor_registry_1 = require("./editor-registry");
+let appDiscovery = null;
+const discoverApps = async () => {
+    const [installedEditors, installedCodingAgents] = await Promise.all([
+        (0, editor_registry_1.getAvailableEditors)(),
+        (0, coding_agent_registry_1.getAvailableCodingAgents)(),
+    ]);
+    const [runningEditors, runningCodingAgents] = await Promise.all([
+        (0, editor_registry_1.getRunningEditors)(installedEditors),
+        (0, coding_agent_registry_1.getRunningCodingAgents)(installedCodingAgents),
+    ]);
+    return {
+        installedEditors,
+        installedCodingAgents,
+        runningEditors,
+        runningCodingAgents,
+    };
+};
+// The terminal helper and Studio requests share the same in-flight discovery
+// and process snapshot. Configuration and app history are read separately.
+const getAppDiscovery = () => {
+    appDiscovery !== null && appDiscovery !== void 0 ? appDiscovery : (appDiscovery = discoverApps());
+    return appDiscovery;
+};
+exports.getAppDiscovery = getAppDiscovery;
+const getEditorInfo = async (configuredEditor) => {
+    const { installedEditors, runningEditors } = await (0, exports.getAppDiscovery)();
+    const customEditor = configuredEditor &&
+        typeof configuredEditor === 'object' &&
+        (0, custom_editor_1.resolveCustomEditorExecutable)(configuredEditor)
+        ? configuredEditor
+        : null;
+    return {
+        defaultEditor: configuredEditor && typeof configuredEditor === 'object'
+            ? 'custom'
+            : configuredEditor,
+        runningEditors,
+        installedEditors: [
+            ...installedEditors.map(({ id, name, nameWithType }) => ({
+                id,
+                name,
+                nameWithType,
+            })),
+            ...(customEditor
+                ? [
+                    {
+                        id: 'custom',
+                        name: customEditor.name,
+                        nameWithType: customEditor.name,
+                    },
+                ]
+                : []),
+        ],
+    };
+};
+exports.getEditorInfo = getEditorInfo;

package/dist/helpers/coding-agent-registry.d.ts

@@ -23,6 +23,7 @@ export type CodingAgentDiscoveryContext = {
 };
 export declare const discoverAvailableCodingAgents: (context: CodingAgentDiscoveryContext) => Promise<readonly InstalledCodingAgent[]>;
 export declare const getAvailableCodingAgents: () => Promise<readonly InstalledCodingAgent[]>;
+export declare const getRunningCodingAgents: (installedCodingAgents: readonly InstalledCodingAgent[]) => Promise<readonly ("claude-code" | "codex" | "copilot" | "cursor")[]>;
 export declare const getCodingAgentLaunchCommand: ({ codingAgent, projectPath, }: {
     codingAgent: InstalledCodingAgent;
     projectPath: string;

package/dist/helpers/coding-agent-registry.js

@@ -3,13 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.launchCodingAgent = exports.getCodingAgentLaunchCommands = exports.getCodingAgentLaunchCommand = exports.getAvailableCodingAgents = exports.discoverAvailableCodingAgents = void 0;
+exports.launchCodingAgent = exports.getCodingAgentLaunchCommands = exports.getCodingAgentLaunchCommand = exports.getRunningCodingAgents = exports.getAvailableCodingAgents = exports.discoverAvailableCodingAgents = void 0;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
 const node_util_1 = require("node:util");
 const renderer_1 = require("@remotion/renderer");
+const running_processes_1 = require("./running-processes");
 const execFilePromise = (0, node_util_1.promisify)(node_child_process_1.execFile);
 const getLinuxCommandPaths = (context, command) => [
     node_path_1.default.posix.join('/usr/local/bin', command),
@@ -302,6 +303,26 @@ const getAvailableCodingAgents = () => {
     return availableCodingAgents;
 };
 exports.getAvailableCodingAgents = getAvailableCodingAgents;
+const getRunningCodingAgents = async (installedCodingAgents) => {
+    if (installedCodingAgents.length === 0) {
+        return [];
+    }
+    const processes = await (0, running_processes_1.getRunningProcesses)();
+    if (processes === null) {
+        return [];
+    }
+    return installedCodingAgents
+        .filter((agent) => (0, running_processes_1.isAppRunning)({
+        processes,
+        executablePath: agent.applicationPath,
+        commands: agent.platform === 'darwin'
+            ? []
+            : codingAgentDefinitions[agent.id][agent.platform].flatMap((variant) => variant.commands),
+        platform: agent.platform,
+    }))
+        .map((agent) => agent.id);
+};
+exports.getRunningCodingAgents = getRunningCodingAgents;
 const getCodingAgentLaunchCommand = ({ codingAgent, projectPath, }) => {
     if (codingAgent.platform === 'darwin') {
         switch (codingAgent.id) {

package/dist/helpers/editor-registry.d.ts

@@ -17,3 +17,4 @@ export type EditorDiscoveryContext = {
 export declare const getDefaultEditorName: (id: "cursor" | "sublime-text" | "vscode" | "vscodium" | "webstorm" | "windsurf" | "zed") => string;
 export declare const discoverAvailableEditors: (context: EditorDiscoveryContext) => Promise<readonly InstalledEditor[]>;
 export declare const getAvailableEditors: () => Promise<readonly InstalledEditor[]>;
+export declare const getRunningEditors: (installedEditors: readonly InstalledEditor[]) => Promise<readonly ("cursor" | "sublime-text" | "vscode" | "vscodium" | "webstorm" | "windsurf" | "zed")[]>;

package/dist/helpers/editor-registry.js

@@ -3,13 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAvailableEditors = exports.discoverAvailableEditors = exports.getDefaultEditorName = void 0;
+exports.getRunningEditors = exports.getAvailableEditors = exports.discoverAvailableEditors = exports.getDefaultEditorName = void 0;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
 const node_util_1 = require("node:util");
 const renderer_1 = require("@remotion/renderer");
+const running_processes_1 = require("./running-processes");
 const execFilePromise = (0, node_util_1.promisify)(node_child_process_1.execFile);
 const getWindowsEnvironmentPaths = (context, segments) => {
     const paths = [];
@@ -526,3 +527,25 @@ const getAvailableEditors = () => {
     return availableEditors;
 };
 exports.getAvailableEditors = getAvailableEditors;
+const getRunningEditors = async (installedEditors) => {
+    const { platform } = process;
+    if (installedEditors.length === 0 ||
+        (platform !== 'darwin' && platform !== 'linux' && platform !== 'win32')) {
+        return [];
+    }
+    const processes = await (0, running_processes_1.getRunningProcesses)();
+    if (processes === null) {
+        return [];
+    }
+    return installedEditors
+        .filter((editor) => (0, running_processes_1.isAppRunning)({
+        processes,
+        executablePath: editor.process,
+        commands: editorDefinitions[editor.id][platform]
+            .map((variant) => 'commands' in variant ? variant.commands : [variant.command])
+            .flat(),
+        platform,
+    }))
+        .map(({ id }) => id);
+};
+exports.getRunningEditors = getRunningEditors;

package/dist/helpers/open-in-app.d.ts

@@ -0,0 +1,13 @@
+import { type DefaultEditor } from '@remotion/renderer';
+import type { OpenInCodingAgentRequest, OpenInCodingAgentResponse, OpenInEditorRequest, OpenInEditorResponse } from '@remotion/studio-shared';
+export declare const openInEditor: ({ input, remotionRoot, logLevel, getDefaultEditor, }: {
+    input: OpenInEditorRequest;
+    remotionRoot: string;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    getDefaultEditor: () => DefaultEditor | null;
+}) => Promise<OpenInEditorResponse>;
+export declare const openInCodingAgent: ({ input, logLevel, remotionRoot, }: {
+    input: OpenInCodingAgentRequest;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    remotionRoot: string;
+}) => Promise<OpenInCodingAgentResponse>;

package/dist/helpers/open-in-app.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openInCodingAgent = exports.openInEditor = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const renderer_1 = require("@remotion/renderer");
+const coding_agent_registry_1 = require("./coding-agent-registry");
+const custom_editor_1 = require("./custom-editor");
+const open_in_editor_1 = require("./open-in-editor");
+const resolve_editor_1 = require("./resolve-editor");
+const openInEditor = async ({ input, remotionRoot, logLevel, getDefaultEditor, }) => {
+    try {
+        if (!('stack' in input)) {
+            throw new TypeError('Need to pass stack');
+        }
+        const { stack } = input;
+        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,
+            }, remotionRoot);
+        return { success: didOpen };
+    }
+    catch (_a) {
+        return { success: false };
+    }
+};
+exports.openInEditor = openInEditor;
+const openInCodingAgent = async ({ input, logLevel, remotionRoot, }) => {
+    const codingAgent = (await (0, coding_agent_registry_1.getAvailableCodingAgents)()).find((agent) => agent.id === input.codingAgentId);
+    if (!codingAgent) {
+        return { success: false };
+    }
+    return {
+        success: await (0, coding_agent_registry_1.launchCodingAgent)({
+            codingAgent,
+            projectPath: remotionRoot,
+            logLevel,
+            prompt: input.prompt,
+        }),
+    };
+};
+exports.openInCodingAgent = openInCodingAgent;

package/dist/helpers/open-in-editor.d.ts

@@ -20,5 +20,5 @@ export declare function launchEditor({ colNumber, editor, fileName, lineNumber,
     editor: ProcessAndCommand;
     vsCodeNewWindow: boolean;
     logLevel: LogLevel;
-}): Promise<boolean>;
+}, projectFolder?: string | null): Promise<boolean>;
 export {};

package/dist/helpers/open-in-editor.js

@@ -1,38 +1,5 @@
 "use strict";
 // Duplicated in create-video/src/open-in-editor.ts
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -40,27 +7,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findMacOsEditorsFromProcessOutput = exports.getDisplayNameForEditor = void 0;
 exports.guessEditor = guessEditor;
 exports.launchEditor = launchEditor;
-const node_child_process_1 = __importStar(require("node:child_process"));
+const node_child_process_1 = __importDefault(require("node:child_process"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
-const node_util_1 = __importDefault(require("node:util"));
 const renderer_1 = require("@remotion/renderer");
 const open_in_editor_url_scheme_1 = require("./open-in-editor-url-scheme");
+const running_processes_1 = require("./running-processes");
 const { Log } = renderer_1.RenderInternals;
-const execProm = node_util_1.default.promisify(node_child_process_1.exec);
 const isVsCodeDerivative = (editor) => {
-    return (editor === 'code' ||
-        editor === 'code-insiders' ||
-        editor === 'Code.exe' ||
-        editor === 'vscodium' ||
-        editor === 'VSCodium.exe' ||
-        editor === 'codium' ||
-        editor === 'Code - Insiders.exe' ||
-        editor === 'cursor' ||
-        editor === 'Cursor.exe' ||
-        editor === 'windsurf' ||
-        editor === 'Windsurf.exe');
+    const editorBasename = node_path_1.default.basename(editor).replace(/\.(exe|cmd|bat)$/i, '');
+    return [
+        'code',
+        'Code',
+        'code-insiders',
+        'Code - Insiders',
+        'vscodium',
+        'VSCodium',
+        'codium',
+        'com.vscodium.codium',
+        'com.visualstudio.code',
+        'com.visualstudio.code.insiders',
+        'cursor',
+        'Cursor',
+        'windsurf',
+        'Windsurf',
+    ].includes(editorBasename);
 };
 function isTerminalEditor(editor) {
     switch (editor) {
@@ -257,6 +229,11 @@ function getArgumentsForLineNumber(editor, fileName, lineNumber, colNumber) {
     if (isZedEditor) {
         return ['--existing', fileName + ':' + lineNumber + ':' + colNumber];
     }
+    if (isVsCodeDerivative(editor)) {
+        return isFolder
+            ? [fileName]
+            : ['-g', fileName + ':' + lineNumber + ':' + colNumber];
+    }
     switch (editorBasename) {
         case 'atom':
         case 'Atom':
@@ -284,21 +261,6 @@ function getArgumentsForLineNumber(editor, fileName, lineNumber, colNumber) {
         case 'mate':
         case 'mine':
             return ['--line', lineNumber, fileName];
-        case 'code':
-        case 'Code':
-        case 'code-insiders':
-        case 'Code - Insiders':
-        case 'vscodium':
-        case 'VSCodium':
-        case 'codium':
-        case 'com.vscodium.codium':
-        case 'com.visualstudio.code':
-        case 'com.visualstudio.code.insiders':
-        case 'cursor':
-        case 'Cursor':
-        case 'windsurf':
-        case 'Windsurf':
-            return ['-g', fileName + ':' + lineNumber + ':' + colNumber];
         case 'appcode':
         case 'clion':
         case 'clion64':
@@ -340,22 +302,20 @@ const findMacOsEditorsFromProcessOutput = (output) => {
 };
 exports.findMacOsEditorsFromProcessOutput = findMacOsEditorsFromProcessOutput;
 async function guessEditor() {
-    // We can find out which editor is currently running by:
-    // `ps x` on macOS and Linux
-    // `Get-Process` on Windows
     const availableEditors = [];
-    try {
+    const processes = await (0, running_processes_1.getRunningProcesses)();
+    if (processes !== null) {
         if (process.platform === 'darwin') {
-            const output = (await execProm('ps x')).stdout.toString();
+            const output = processes
+                .map(({ executable }) => executable !== null && executable !== void 0 ? executable : '')
+                .join('\n');
             return (0, exports.findMacOsEditorsFromProcessOutput)(output);
         }
         if (process.platform === 'win32') {
-            // Some processes need elevated rights to get its executable path.
-            // Just filter them out upfront. This also saves 10-20ms on the command.
-            const output = (await execProm('wmic process where "executablepath is not null" get executablepath')).stdout.toString();
-            const runningProcesses = output.split('\r\n');
-            for (let i = 0; i < runningProcesses.length; i++) {
-                const processPath = runningProcesses[i].trim();
+            for (const { executable: processPath } of processes) {
+                if (processPath === null) {
+                    continue;
+                }
                 const processName = node_path_1.default.basename(processPath);
                 if (COMMON_EDITORS_WIN.indexOf(processName) !== -1) {
                     availableEditors.push({
@@ -367,10 +327,9 @@ async function guessEditor() {
             return availableEditors;
         }
         if (process.platform === 'linux') {
-            // --no-heading No header line
-            // x List all processes owned by you
-            // -o comm Need only names column
-            const output = (await execProm('ps x --no-heading -o comm --sort=comm')).stdout.toString();
+            const output = processes
+                .map(({ executable }) => executable !== null && executable !== void 0 ? executable : '')
+                .join('\n');
             const processNames = Object.keys(COMMON_EDITORS_LINUX);
             for (let i = 0; i < processNames.length; i++) {
                 const processName = processNames[i];
@@ -384,9 +343,6 @@ async function guessEditor() {
             return availableEditors;
         }
     }
-    catch (_a) {
-        // Ignore...
-    }
     // Last resort, use old skool env vars
     if (process.env.VISUAL) {
         return [
@@ -407,7 +363,8 @@ async function guessEditor() {
     return [];
 }
 let _childProcess = null;
-async function launchEditor({ colNumber, editor, fileName, lineNumber, vsCodeNewWindow, logLevel, }) {
+async function launchEditor({ colNumber, editor, fileName, lineNumber, vsCodeNewWindow, logLevel, }, projectFolder = null) {
+    var _a;
     if (!node_fs_1.default.existsSync(fileName)) {
         return false;
     }
@@ -425,6 +382,8 @@ async function launchEditor({ colNumber, editor, fileName, lineNumber, vsCodeNew
     if (editor.command.toLowerCase() === 'none') {
         return false;
     }
+    const isDirectory = node_fs_1.default.statSync(fileName).isDirectory();
+    let folderToOpen = isVsCodeDerivative(editor.command) && !isDirectory ? projectFolder : null;
     if (process.platform === 'linux' &&
         fileName.startsWith('/mnt/') &&
         /Microsoft/i.test(node_os_1.default.release())) {
@@ -435,13 +394,16 @@ async function launchEditor({ colNumber, editor, fileName, lineNumber, vsCodeNew
         // When a Windows editor is specified, interop functionality can
         // handle the path translation, but only if a relative path is used.
         fileName = node_path_1.default.relative('', fileName);
+        if (folderToOpen !== null) {
+            folderToOpen = node_path_1.default.relative('', folderToOpen);
+        }
     }
     // cmd.exe on Windows is vulnerable to RCE attacks given a file name of the
     // form "C:\Users\myusername\Downloads\& curl 172.21.93.52". Use a whitelist
     // to validate user-provided file names. This doesn't cover the entire range
     // of valid file names but should cover almost all of them in practice.
     if (process.platform === 'win32' &&
-        !WINDOWS_FILE_NAME_WHITELIST.test(fileName.trim())) {
+        [fileName, folderToOpen].some((target) => target !== null && !WINDOWS_FILE_NAME_WHITELIST.test(target.trim()))) {
         Log.error({ indent: false, logLevel });
         Log.error({ indent: false, logLevel }, 'Could not open ' + node_path_1.default.basename(fileName) + ' in the editor.');
         Log.error({ indent: false, logLevel });
@@ -453,7 +415,8 @@ async function launchEditor({ colNumber, editor, fileName, lineNumber, vsCodeNew
         return false;
     }
     const shouldOpenVsCodeNewWindow = isVsCodeDerivative(editor.command) && vsCodeNewWindow;
-    if (!shouldOpenVsCodeNewWindow) {
+    // The file URL cannot specify both a workspace folder and a source location.
+    if (!shouldOpenVsCodeNewWindow && folderToOpen === null && !isDirectory) {
         const result = (0, open_in_editor_url_scheme_1.openInEditorViaUrlScheme)({
             editor: editor.command,
             fileName,
@@ -469,9 +432,29 @@ async function launchEditor({ colNumber, editor, fileName, lineNumber, vsCodeNew
     }
     const args = shouldOpenVsCodeNewWindow
         ? ['--new-window', fileName]
-        : lineNumber
+        : lineNumber && !isDirectory
             ? getArgumentsForLineNumber(editor.command, fileName, String(lineNumber), colNumber)
             : [fileName];
+    if (folderToOpen !== null) {
+        args.unshift(folderToOpen);
+    }
+    if (process.platform === 'darwin' &&
+        isVsCodeDerivative(editor.command) &&
+        (folderToOpen !== null || isDirectory)) {
+        const applicationPath = (_a = editor.process.match(/^(.*?\.app)\/Contents\//)) === null || _a === void 0 ? void 0 : _a[1];
+        if (applicationPath && node_fs_1.default.existsSync(applicationPath)) {
+            // Match the CLI's native macOS launch without starting its Node.js wrapper.
+            // -n lets Electron receive the arguments and forward them to a running instance.
+            const opened = await new Promise((resolve) => {
+                const proc = node_child_process_1.default.spawn('open', ['-n', '-g', '-a', applicationPath, '--args', ...args], { stdio: 'ignore' });
+                proc.on('error', () => resolve(false));
+                proc.on('close', (code) => resolve(code === 0));
+            });
+            if (opened) {
+                return true;
+            }
+        }
+    }
     if (_childProcess && isTerminalEditor(editor.command)) {
         // There's an existing editor process already and it's attached
         // to the terminal, so go kill it. Otherwise two separate editor

package/dist/helpers/recently-used-apps.d.ts

@@ -0,0 +1,9 @@
+export declare const subscribeToRecentlyUsedApps: ({ remotionRoot, onChange, }: {
+    remotionRoot: string;
+    onChange: () => void;
+}) => () => void;
+export declare const getRecentlyUsedApps: ({ remotionRoot, type, recentlyUsedIds, }: {
+    remotionRoot: string;
+    type: "coding-agent" | "editor";
+    recentlyUsedIds: readonly string[] | null;
+}) => Promise<readonly string[]>;

package/dist/helpers/recently-used-apps.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRecentlyUsedApps = exports.subscribeToRecentlyUsedApps = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const renderer_1 = require("@remotion/renderer");
+const histories = new Map();
+const historyListeners = new Set();
+const subscribeToRecentlyUsedApps = ({ remotionRoot, onChange, }) => {
+    const listener = { remotionRoot, onChange };
+    historyListeners.add(listener);
+    return () => {
+        historyListeners.delete(listener);
+    };
+};
+exports.subscribeToRecentlyUsedApps = subscribeToRecentlyUsedApps;
+const getRecentlyUsedApps = ({ remotionRoot, type, recentlyUsedIds, }) => {
+    var _a;
+    const filePath = node_path_1.default.join(remotionRoot, 'node_modules', '.cache', 'remotion', `recently-used-${type}s.json`);
+    const allowedIds = type === 'editor' ? [...renderer_1.defaultEditorIds, 'custom'] : renderer_1.defaultCodingAgentIds;
+    const previous = (_a = histories.get(filePath)) !== null && _a !== void 0 ? _a : (async () => {
+        try {
+            const stored = JSON.parse(await (0, promises_1.readFile)(filePath, 'utf8'));
+            return Array.isArray(stored)
+                ? [
+                    ...new Set(stored.filter((id) => allowedIds.includes(id))),
+                ]
+                : [];
+        }
+        catch (_a) {
+            return [];
+        }
+    })();
+    const history = previous.then(async (ids) => {
+        if (recentlyUsedIds === null) {
+            return ids;
+        }
+        const updatedIds = [
+            ...new Set(recentlyUsedIds.filter((id) => allowedIds.includes(id))),
+        ];
+        if (JSON.stringify(ids) !== JSON.stringify(updatedIds)) {
+            try {
+                await (0, promises_1.mkdir)(node_path_1.default.dirname(filePath), { recursive: true });
+                await (0, promises_1.writeFile)(filePath, JSON.stringify(updatedIds));
+            }
+            catch (_a) {
+                // Keep the history in memory when the project cache is not writable.
+            }
+            historyListeners.forEach((listener) => {
+                if (listener.remotionRoot === remotionRoot) {
+                    listener.onChange();
+                }
+            });
+        }
+        return updatedIds;
+    });
+    histories.set(filePath, history);
+    return history;
+};
+exports.getRecentlyUsedApps = getRecentlyUsedApps;

package/dist/helpers/running-processes.d.ts

@@ -0,0 +1,12 @@
+type RunningProcess = {
+    executable: string | null;
+    commandLine: string | null;
+};
+export declare const isAppRunning: ({ processes, executablePath, commands, platform, }: {
+    processes: readonly RunningProcess[];
+    executablePath: string;
+    commands: readonly string[];
+    platform: NodeJS.Platform;
+}) => boolean;
+export declare const getRunningProcesses: () => Promise<readonly RunningProcess[] | null>;
+export {};