@remotion/studio-server 4.0.506 → 4.0.507

package/dist/codemods/effect-param-expression.js

@@ -76,6 +76,8 @@ const makeEasingExpression = ({ easing, easingLocalName, }) => {
     switch (easing.type) {
         case 'linear':
             return b.memberExpression(b.identifier(easingLocalName), b.identifier('linear'));
+        case 'step1':
+            return b.memberExpression(b.identifier(easingLocalName), b.identifier('step1'));
         case 'spring':
             return b.callExpression(b.memberExpression(b.identifier(easingLocalName), b.identifier('spring')), [
                 b.objectExpression([

package/dist/codemods/update-keyframes/update-keyframes.js

@@ -285,6 +285,8 @@ const createEasingExpression = (easing) => {
     switch (easing.type) {
         case 'linear':
             return b.memberExpression(b.identifier('Easing'), b.identifier('linear'));
+        case 'step1':
+            return b.memberExpression(b.identifier('Easing'), b.identifier('step1'));
         case 'spring':
             return b.callExpression(b.memberExpression(b.identifier('Easing'), b.identifier('spring')), [
                 b.objectExpression([

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

@@ -2,13 +2,48 @@ import type { DefaultCodingAgent } from '@remotion/renderer';
 export type InstalledCodingAgent = {
     id: DefaultCodingAgent;
     name: string;
+    nameWithType: string;
     applicationPath: string;
+    iconDataUrl: string | null;
+    platform: SupportedCodingAgentPlatform;
+    launchMode: 'direct' | 'terminal';
+    terminal: InstalledTerminal | null;
+};
+type SupportedCodingAgentPlatform = 'darwin' | 'linux' | 'win32';
+type LinuxTerminalId = 'x-terminal-emulator' | 'gnome-terminal' | 'konsole' | 'kitty' | 'alacritty' | 'wezterm' | 'xterm';
+type InstalledTerminal = {
+    id: LinuxTerminalId | 'cmd';
+    path: string;
 };
 export type CodingAgentDiscoveryContext = {
     platform: NodeJS.Platform;
+    env: NodeJS.ProcessEnv;
     homeDirectory: string;
     pathExists: (filePath: string) => boolean;
     findMacApplications: (bundleIdentifier: string) => Promise<readonly string[]>;
 };
 export declare const discoverAvailableCodingAgents: (context: CodingAgentDiscoveryContext) => Promise<readonly InstalledCodingAgent[]>;
 export declare const getAvailableCodingAgents: () => Promise<readonly InstalledCodingAgent[]>;
+export declare const getCodingAgentLaunchCommand: ({ codingAgent, projectPath, }: {
+    codingAgent: InstalledCodingAgent;
+    projectPath: string;
+}) => {
+    command: string;
+    args: string[];
+    cwd: string | null;
+};
+type CodingAgentLaunchCommand = ReturnType<typeof getCodingAgentLaunchCommand> & {
+    waitForExit: boolean;
+};
+export declare const getCodingAgentLaunchCommands: ({ codingAgent, projectPath, prompt, }: {
+    codingAgent: InstalledCodingAgent;
+    projectPath: string;
+    prompt: string | null;
+}) => readonly CodingAgentLaunchCommand[];
+export declare const launchCodingAgent: ({ codingAgent, projectPath, logLevel, prompt, }: {
+    codingAgent: InstalledCodingAgent;
+    projectPath: string;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    prompt: string | null;
+}) => Promise<boolean>;
+export {};

package/dist/helpers/coding-agent-registry.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.getAvailableCodingAgents = exports.discoverAvailableCodingAgents = void 0;
+exports.launchCodingAgent = exports.getCodingAgentLaunchCommands = exports.getCodingAgentLaunchCommand = 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");
@@ -11,28 +11,165 @@ const node_path_1 = __importDefault(require("node:path"));
 const node_util_1 = require("node:util");
 const renderer_1 = require("@remotion/renderer");
 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),
+    node_path_1.default.posix.join('/usr/bin', command),
+    node_path_1.default.posix.join(context.homeDirectory, '.local/bin', command),
+];
+const getWindowsCommandPaths = (context, command) => [
+    node_path_1.default.win32.join(context.homeDirectory, '.local', 'bin', `${command}.exe`),
+    node_path_1.default.win32.join(context.homeDirectory, '.local', 'bin', `${command}.cmd`),
+];
+const getWindowsEnvironmentPaths = (context, segments) => {
+    const paths = [];
+    if (context.env.LOCALAPPDATA) {
+        paths.push(node_path_1.default.win32.join(context.env.LOCALAPPDATA, 'Programs', ...segments));
+    }
+    for (const directory of [
+        context.env.ProgramFiles,
+        context.env['ProgramFiles(x86)'],
+    ]) {
+        if (directory) {
+            paths.push(node_path_1.default.win32.join(directory, ...segments));
+        }
+    }
+    return paths;
+};
 const codingAgentDefinitions = {
     codex: {
         name: 'Codex',
-        bundleIdentifiers: ['com.openai.codex'],
-        applicationNames: ['ChatGPT.app'],
+        nameWithType: 'Codex',
+        darwin: {
+            bundleIdentifiers: ['com.openai.codex'],
+            applicationNames: ['ChatGPT.app'],
+        },
+        linux: [
+            {
+                paths: (context) => getLinuxCommandPaths(context, 'codex'),
+                commands: ['codex'],
+                launchMode: 'terminal',
+            },
+        ],
+        win32: [
+            {
+                paths: (context) => [
+                    ...getWindowsCommandPaths(context, 'codex'),
+                    ...(context.env.LOCALAPPDATA
+                        ? [
+                            node_path_1.default.win32.join(context.env.LOCALAPPDATA, 'OpenAI', 'Codex', 'bin', 'codex.exe'),
+                            node_path_1.default.win32.join(context.env.LOCALAPPDATA, 'Packages', 'OpenAI.Codex_2p2nqsd0c76g0', 'LocalCache', 'Local', 'OpenAI', 'Codex', 'bin', 'codex.exe'),
+                        ]
+                        : []),
+                ],
+                commands: ['codex.exe', 'codex.cmd'],
+                launchMode: 'terminal',
+            },
+        ],
     },
     cursor: {
         name: 'Cursor',
-        bundleIdentifiers: ['com.todesktop.230313mzl4w4u92'],
-        applicationNames: ['Cursor.app'],
+        nameWithType: 'Cursor Agent',
+        darwin: {
+            bundleIdentifiers: ['com.todesktop.230313mzl4w4u92'],
+            applicationNames: ['Cursor.app'],
+        },
+        linux: [
+            {
+                paths: (context) => getLinuxCommandPaths(context, 'cursor'),
+                commands: ['cursor'],
+                launchMode: 'direct',
+            },
+            {
+                paths: (context) => [
+                    ...getLinuxCommandPaths(context, 'cursor-agent'),
+                    node_path_1.default.posix.join(context.homeDirectory, '.cursor/bin/cursor-agent'),
+                ],
+                commands: ['cursor-agent'],
+                launchMode: 'terminal',
+            },
+        ],
+        win32: [
+            {
+                paths: (context) => getWindowsEnvironmentPaths(context, ['cursor', 'Cursor.exe']),
+                commands: ['Cursor.exe', 'cursor.cmd'],
+                launchMode: 'direct',
+            },
+            {
+                paths: (context) => getWindowsCommandPaths(context, 'cursor-agent'),
+                commands: ['cursor-agent.exe', 'cursor-agent.cmd'],
+                launchMode: 'terminal',
+            },
+        ],
     },
-    'github-copilot': {
+    copilot: {
         name: 'GitHub Copilot',
-        bundleIdentifiers: ['com.github.githubapp'],
-        applicationNames: ['GitHub Copilot.app'],
+        nameWithType: 'GitHub Copilot',
+        darwin: {
+            bundleIdentifiers: ['com.github.githubapp'],
+            applicationNames: ['GitHub Copilot.app'],
+        },
+        linux: [
+            {
+                paths: (context) => getLinuxCommandPaths(context, 'copilot'),
+                commands: ['copilot'],
+                launchMode: 'terminal',
+            },
+        ],
+        win32: [
+            {
+                paths: (context) => getWindowsCommandPaths(context, 'copilot'),
+                commands: ['copilot.exe', 'copilot.cmd'],
+                launchMode: 'terminal',
+            },
+        ],
     },
     'claude-code': {
         name: 'Claude Code',
-        bundleIdentifiers: ['com.anthropic.claudefordesktop'],
-        applicationNames: ['Claude.app'],
+        nameWithType: 'Claude Code',
+        darwin: {
+            bundleIdentifiers: ['com.anthropic.claudefordesktop'],
+            applicationNames: ['Claude.app'],
+        },
+        linux: [
+            {
+                paths: (context) => [
+                    ...getLinuxCommandPaths(context, 'claude'),
+                    node_path_1.default.posix.join(context.homeDirectory, '.claude/local/claude'),
+                ],
+                commands: ['claude'],
+                launchMode: 'terminal',
+            },
+        ],
+        win32: [
+            {
+                paths: (context) => getWindowsCommandPaths(context, 'claude'),
+                commands: ['claude.exe', 'claude.cmd'],
+                launchMode: 'terminal',
+            },
+        ],
     },
 };
+const linuxTerminalDefinitions = [
+    {
+        id: 'x-terminal-emulator',
+        paths: ['/usr/bin/x-terminal-emulator'],
+        commands: ['x-terminal-emulator'],
+    },
+    {
+        id: 'gnome-terminal',
+        paths: ['/usr/bin/gnome-terminal'],
+        commands: ['gnome-terminal'],
+    },
+    {
+        id: 'konsole',
+        paths: ['/usr/bin/konsole'],
+        commands: ['konsole'],
+    },
+    { id: 'kitty', paths: ['/usr/bin/kitty'], commands: ['kitty'] },
+    { id: 'alacritty', paths: ['/usr/bin/alacritty'], commands: ['alacritty'] },
+    { id: 'wezterm', paths: ['/usr/bin/wezterm'], commands: ['wezterm'] },
+    { id: 'xterm', paths: ['/usr/bin/xterm'], commands: ['xterm'] },
+];
 const findMacApplications = async (bundleIdentifier) => {
     try {
         const { stdout } = await execFilePromise('mdfind', [
@@ -47,39 +184,120 @@ const findMacApplications = async (bundleIdentifier) => {
         return [];
     }
 };
+const getBundledCodingAgentIconDataUrl = (id) => `data:image/png;base64,${(0, node_fs_1.readFileSync)(node_path_1.default.join(__dirname, '..', '..', 'web', 'coding-agent-icons', `${id}.png`)).toString('base64')}`;
 const defaultDiscoveryContext = {
     platform: process.platform,
+    env: process.env,
     homeDirectory: (0, node_os_1.homedir)(),
     pathExists: node_fs_1.existsSync,
     findMacApplications,
 };
+const getPathDirectories = (context) => {
+    var _a, _b;
+    const value = (_b = (_a = context.env.PATH) !== null && _a !== void 0 ? _a : context.env.Path) !== null && _b !== void 0 ? _b : '';
+    return value.split(context.platform === 'win32' ? ';' : ':').filter(Boolean);
+};
+const findExecutable = ({ paths, commands, context, }) => {
+    for (const executablePath of paths) {
+        if (context.pathExists(executablePath)) {
+            return executablePath;
+        }
+    }
+    const pathImplementation = context.platform === 'win32' ? node_path_1.default.win32 : node_path_1.default.posix;
+    for (const directory of getPathDirectories(context)) {
+        for (const command of commands) {
+            const executablePath = pathImplementation.join(directory, command);
+            if (context.pathExists(executablePath)) {
+                return executablePath;
+            }
+        }
+    }
+    return null;
+};
+const findLinuxTerminal = (context) => {
+    for (const definition of linuxTerminalDefinitions) {
+        const terminalPath = findExecutable({
+            paths: definition.paths,
+            commands: definition.commands,
+            context,
+        });
+        if (terminalPath) {
+            return { id: definition.id, path: terminalPath };
+        }
+    }
+    return null;
+};
 const discoverAvailableCodingAgents = async (context) => {
-    if (context.platform !== 'darwin') {
+    var _a, _b;
+    if (context.platform !== 'darwin' &&
+        context.platform !== 'linux' &&
+        context.platform !== 'win32') {
         return [];
     }
+    const { platform } = context;
+    const terminal = platform === 'linux'
+        ? findLinuxTerminal(context)
+        : platform === 'win32'
+            ? {
+                id: 'cmd',
+                path: (_b = (_a = context.env.ComSpec) !== null && _a !== void 0 ? _a : context.env.COMSPEC) !== null && _b !== void 0 ? _b : 'cmd.exe',
+            }
+            : null;
     const installedCodingAgents = [];
     for (const id of renderer_1.defaultCodingAgentIds) {
         const definition = codingAgentDefinitions[id];
-        const discoveredApplications = (await Promise.all(definition.bundleIdentifiers.map((bundleIdentifier) => context.findMacApplications(bundleIdentifier)))).flat();
-        const knownApplications = definition.applicationNames.flatMap((name) => [
-            node_path_1.default.posix.join('/Applications', name),
-            node_path_1.default.posix.join(context.homeDirectory, 'Applications', name),
-        ]);
-        for (const applicationPath of new Set([
-            ...discoveredApplications,
-            ...knownApplications,
-        ])) {
-            if (context.pathExists(applicationPath)) {
+        if (platform === 'darwin') {
+            const discoveredApplications = (await Promise.all(definition.darwin.bundleIdentifiers.map((bundleIdentifier) => context.findMacApplications(bundleIdentifier)))).flat();
+            const knownApplications = definition.darwin.applicationNames.flatMap((name) => [
+                node_path_1.default.posix.join('/Applications', name),
+                node_path_1.default.posix.join(context.homeDirectory, 'Applications', name),
+            ]);
+            for (const applicationPath of new Set([
+                ...discoveredApplications,
+                ...knownApplications,
+            ])) {
+                if (context.pathExists(applicationPath)) {
+                    installedCodingAgents.push({
+                        applicationPath,
+                        id,
+                        launchMode: 'direct',
+                        name: definition.name,
+                        nameWithType: definition.nameWithType,
+                        platform,
+                        terminal: null,
+                    });
+                    break;
+                }
+            }
+            continue;
+        }
+        for (const variant of definition[platform]) {
+            if (variant.launchMode === 'terminal' && terminal === null) {
+                continue;
+            }
+            const applicationPath = findExecutable({
+                paths: variant.paths(context),
+                commands: variant.commands,
+                context,
+            });
+            if (applicationPath) {
                 installedCodingAgents.push({
                     applicationPath,
                     id,
+                    launchMode: variant.launchMode,
                     name: definition.name,
+                    nameWithType: definition.nameWithType,
+                    platform,
+                    terminal: variant.launchMode === 'terminal' ? terminal : null,
                 });
                 break;
             }
         }
     }
-    return installedCodingAgents;
+    return installedCodingAgents.map((codingAgent) => ({
+        ...codingAgent,
+        iconDataUrl: getBundledCodingAgentIconDataUrl(codingAgent.id),
+    }));
 };
 exports.discoverAvailableCodingAgents = discoverAvailableCodingAgents;
 let availableCodingAgents = null;
@@ -88,3 +306,210 @@ const getAvailableCodingAgents = () => {
     return availableCodingAgents;
 };
 exports.getAvailableCodingAgents = getAvailableCodingAgents;
+const getCodingAgentLaunchCommand = ({ codingAgent, projectPath, }) => {
+    if (codingAgent.platform === 'darwin') {
+        switch (codingAgent.id) {
+            case 'codex':
+                return {
+                    command: node_path_1.default.posix.join(codingAgent.applicationPath, 'Contents/Resources/codex'),
+                    args: ['app', projectPath],
+                    cwd: null,
+                };
+            case 'cursor':
+                return {
+                    command: node_path_1.default.posix.join(codingAgent.applicationPath, 'Contents/Resources/app/bin/cursor'),
+                    args: ['--glass', '--suppress-popups-on-startup', projectPath],
+                    cwd: null,
+                };
+            case 'copilot':
+            case 'claude-code':
+                return {
+                    command: 'open',
+                    args: ['-a', codingAgent.applicationPath, projectPath],
+                    cwd: null,
+                };
+            default: {
+                const invalidId = codingAgent.id;
+                throw new Error(`Unknown coding agent: ${invalidId}`);
+            }
+        }
+    }
+    if (codingAgent.launchMode === 'direct') {
+        return {
+            command: codingAgent.applicationPath,
+            args: codingAgent.id === 'cursor'
+                ? ['--glass', '--suppress-popups-on-startup', projectPath]
+                : [projectPath],
+            cwd: null,
+        };
+    }
+    if (codingAgent.terminal === null) {
+        throw new Error(`No terminal found for coding agent ${codingAgent.name}`);
+    }
+    if (codingAgent.terminal.id === 'cmd') {
+        return {
+            command: codingAgent.terminal.path,
+            args: [
+                '/d',
+                '/s',
+                '/c',
+                'start',
+                '',
+                '/d',
+                projectPath,
+                codingAgent.terminal.path,
+                '/k',
+                codingAgent.applicationPath,
+            ],
+            cwd: null,
+        };
+    }
+    const command = codingAgent.applicationPath;
+    switch (codingAgent.terminal.id) {
+        case 'gnome-terminal':
+            return {
+                command: codingAgent.terminal.path,
+                args: [`--working-directory=${projectPath}`, '--', command],
+                cwd: projectPath,
+            };
+        case 'konsole':
+            return {
+                command: codingAgent.terminal.path,
+                args: ['--workdir', projectPath, '-e', command],
+                cwd: projectPath,
+            };
+        case 'kitty':
+            return {
+                command: codingAgent.terminal.path,
+                args: ['--directory', projectPath, command],
+                cwd: projectPath,
+            };
+        case 'alacritty':
+            return {
+                command: codingAgent.terminal.path,
+                args: ['--working-directory', projectPath, '-e', command],
+                cwd: projectPath,
+            };
+        case 'wezterm':
+            return {
+                command: codingAgent.terminal.path,
+                args: ['start', '--cwd', projectPath, '--', command],
+                cwd: projectPath,
+            };
+        case 'x-terminal-emulator':
+        case 'xterm':
+            return {
+                command: codingAgent.terminal.path,
+                args: ['-e', command],
+                cwd: projectPath,
+            };
+        default: {
+            const invalidTerminal = codingAgent.terminal.id;
+            throw new Error(`Unknown terminal: ${invalidTerminal}`);
+        }
+    }
+};
+exports.getCodingAgentLaunchCommand = getCodingAgentLaunchCommand;
+const getCodingAgentLaunchCommands = ({ codingAgent, projectPath, prompt, }) => {
+    const defaultCommand = {
+        ...(0, exports.getCodingAgentLaunchCommand)({ codingAgent, projectPath }),
+        waitForExit: false,
+    };
+    if (prompt === null ||
+        codingAgent.platform !== 'darwin' ||
+        codingAgent.id === 'copilot') {
+        return [defaultCommand];
+    }
+    switch (codingAgent.id) {
+        case 'codex': {
+            const deepLink = new URL('codex://new');
+            deepLink.searchParams.set('path', projectPath);
+            deepLink.searchParams.set('prompt', prompt);
+            return [
+                {
+                    command: 'open',
+                    args: [deepLink.toString()],
+                    cwd: null,
+                    waitForExit: false,
+                },
+            ];
+        }
+        case 'cursor': {
+            const deepLink = new URL('cursor://anysphere.cursor-deeplink/prompt');
+            deepLink.searchParams.set('text', prompt);
+            return [
+                { ...defaultCommand, waitForExit: true },
+                {
+                    command: 'open',
+                    args: [deepLink.toString()],
+                    cwd: null,
+                    waitForExit: false,
+                },
+            ];
+        }
+        case 'claude-code': {
+            const deepLink = new URL('claude://code/new');
+            deepLink.searchParams.set('folder', projectPath);
+            deepLink.searchParams.set('q', prompt);
+            return [
+                {
+                    command: 'open',
+                    args: [deepLink.toString()],
+                    cwd: null,
+                    waitForExit: false,
+                },
+            ];
+        }
+        default: {
+            const invalidId = codingAgent.id;
+            throw new Error(`Unknown coding agent: ${invalidId}`);
+        }
+    }
+};
+exports.getCodingAgentLaunchCommands = getCodingAgentLaunchCommands;
+const launchCodingAgent = async ({ codingAgent, projectPath, logLevel, prompt, }) => {
+    const commands = (0, exports.getCodingAgentLaunchCommands)({
+        codingAgent,
+        projectPath,
+        prompt,
+    });
+    for (const { command, args, cwd, waitForExit } of commands) {
+        const success = await new Promise((resolve) => {
+            try {
+                const child = (0, node_child_process_1.spawn)(command, args, {
+                    cwd: cwd !== null && cwd !== void 0 ? cwd : undefined,
+                    detached: !waitForExit,
+                    shell: false,
+                    stdio: 'ignore',
+                });
+                child.once('error', (error) => {
+                    renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, `Could not launch coding agent ${codingAgent.name}:`, error);
+                    resolve(false);
+                });
+                if (waitForExit) {
+                    child.once('exit', (code) => {
+                        if (code !== 0) {
+                            renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, `Could not launch coding agent ${codingAgent.name}: Process exited with code ${code}`);
+                        }
+                        resolve(code === 0);
+                    });
+                }
+                else {
+                    child.once('spawn', () => {
+                        child.unref();
+                        resolve(true);
+                    });
+                }
+            }
+            catch (error) {
+                renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, `Could not launch coding agent ${codingAgent.name}:`, error);
+                resolve(false);
+            }
+        });
+        if (!success) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.launchCodingAgent = launchCodingAgent;

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

@@ -2,6 +2,7 @@ import type { BuiltInEditor } from '@remotion/renderer';
 export type InstalledEditor = {
     id: BuiltInEditor;
     name: string;
+    nameWithType: string;
     process: string;
     command: string;
 };