@remotion/studio-server 4.0.502 → 4.0.504

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

@@ -0,0 +1,25 @@
+import type { RemotionSkillName } from './remotion-skill-names';
+export type RemotionSkillsScope = 'project' | 'global';
+export type RemotionSkillsStatus = {
+    type: 'not-installed';
+    scope: RemotionSkillsScope;
+    skillsDirectory: string;
+} | {
+    type: 'up-to-date';
+    scope: RemotionSkillsScope;
+    skillsDirectory: string;
+} | {
+    type: 'outdated';
+    scope: RemotionSkillsScope;
+    skillsDirectory: string;
+    outdatedSkillNames: RemotionSkillName[];
+};
+export declare const parseRemotionSkillVersion: (contents: string) => string | null;
+export declare const detectOutdatedRemotionSkills: ({ currentVersion, cwd, homeDirectory, }?: {
+    currentVersion?: string | undefined;
+    cwd?: string | undefined;
+    homeDirectory?: string | undefined;
+}) => {
+    project: RemotionSkillsStatus;
+    global: RemotionSkillsStatus;
+};

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

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectOutdatedRemotionSkills = 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"));
+const version_1 = require("remotion/version");
+const semver_1 = __importDefault(require("semver"));
+const remotion_skill_names_1 = require("./remotion-skill-names");
+const parseRemotionSkillVersion = (contents) => {
+    var _a, _b, _c, _d;
+    var _e;
+    const frontmatter = (_b = (_a = contents.match(/^---\r?\n(?<frontmatter>[\s\S]*?)\r?\n---(?:\r?\n|$)/)) === null || _a === void 0 ? void 0 : _a.groups) === null || _b === void 0 ? void 0 : _b.frontmatter;
+    if (!frontmatter) {
+        return null;
+    }
+    return ((_e = (_d = (_c = frontmatter.match(/^version:\s*(?<quote>['"]?)(?<version>[^\s'"]+)\k<quote>\s*$/m)) === null || _c === void 0 ? void 0 : _c.groups) === null || _d === void 0 ? void 0 : _d.version) !== null && _e !== void 0 ? _e : null);
+};
+exports.parseRemotionSkillVersion = parseRemotionSkillVersion;
+const readRemotionSkill = (skillFile) => {
+    if (!(0, node_fs_1.existsSync)(skillFile)) {
+        return { installed: false, version: null };
+    }
+    try {
+        return {
+            installed: true,
+            version: (0, exports.parseRemotionSkillVersion)((0, node_fs_1.readFileSync)(skillFile, 'utf8')),
+        };
+    }
+    catch (_a) {
+        return { installed: true, version: null };
+    }
+};
+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')));
+    }
+    if ([...installedSkills.values()].every((skill) => !skill.installed)) {
+        return { type: 'not-installed', scope, skillsDirectory };
+    }
+    const outdatedSkillNames = remotion_skill_names_1.remotionSkillNames.filter((skillName) => {
+        const skill = installedSkills.get(skillName);
+        return (!(skill === null || skill === void 0 ? void 0 : skill.installed) ||
+            skill.version === null ||
+            semver_1.default.valid(skill.version) === null ||
+            semver_1.default.lt(skill.version, currentVersion));
+    });
+    if (outdatedSkillNames.length > 0) {
+        return { type: 'outdated', scope, skillsDirectory, outdatedSkillNames };
+    }
+    return { type: 'up-to-date', scope, skillsDirectory };
+};
+const detectOutdatedRemotionSkills = ({ currentVersion = version_1.VERSION, cwd = process.cwd(), homeDirectory = (0, node_os_1.homedir)(), } = {}) => {
+    const projectSkillsDirectory = node_path_1.default.join(cwd, '.agents', 'skills');
+    const globalSkillsDirectory = node_path_1.default.join(homeDirectory, '.agents', 'skills');
+    return {
+        project: getStatusForSkillsDirectory({
+            currentVersion,
+            scope: 'project',
+            skillsDirectory: projectSkillsDirectory,
+        }),
+        global: getStatusForSkillsDirectory({
+            currentVersion,
+            scope: 'global',
+            skillsDirectory: globalSkillsDirectory,
+        }),
+    };
+};
+exports.detectOutdatedRemotionSkills = detectOutdatedRemotionSkills;

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

@@ -0,0 +1,37 @@
+import { spawn } from 'node:child_process';
+import type { CustomEditor } from '@remotion/renderer';
+type CustomEditorPathType = 'file' | 'directory' | 'symbolic-link' | null;
+export type CustomEditorResolutionContext = {
+    platform: NodeJS.Platform;
+    env: NodeJS.ProcessEnv;
+    currentWorkingDirectory: string;
+    inspectPath: (filePath: string) => CustomEditorPathType;
+    canExecute: (filePath: string) => boolean;
+};
+export type ResolvedCustomEditorExecutable = {
+    executable: string;
+    spawnAsMacApplication: boolean;
+};
+export declare const resolveCustomEditorExecutable: (editor: CustomEditor, context?: CustomEditorResolutionContext) => ResolvedCustomEditorExecutable | null;
+export declare const normalizeCustomEditorTargetPath: ({ targetPath, platform, release, currentWorkingDirectory, }: {
+    targetPath: string;
+    platform: NodeJS.Platform;
+    release: string;
+    currentWorkingDirectory: string;
+}) => string;
+export declare const expandCustomEditorArguments: ({ argumentTemplates, targetPath, lineNumber, columnNumber, }: {
+    argumentTemplates: readonly string[];
+    targetPath: string;
+    lineNumber: number;
+    columnNumber: number;
+}) => string[];
+export declare const launchCustomEditor: ({ editor, resolvedExecutable, targetPath, lineNumber, columnNumber, logLevel, spawnProcess, }: {
+    editor: CustomEditor;
+    resolvedExecutable: ResolvedCustomEditorExecutable;
+    targetPath: string;
+    lineNumber: number;
+    columnNumber: number;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    spawnProcess: typeof spawn | null;
+}) => Promise<boolean>;
+export {};

package/dist/helpers/custom-editor.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchCustomEditor = exports.expandCustomEditorArguments = exports.normalizeCustomEditorTargetPath = exports.resolveCustomEditorExecutable = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const renderer_1 = require("@remotion/renderer");
+const defaultResolutionContext = {
+    platform: process.platform,
+    env: process.env,
+    currentWorkingDirectory: process.cwd(),
+    inspectPath: (filePath) => {
+        try {
+            const stat = (0, node_fs_1.lstatSync)(filePath);
+            if (stat.isSymbolicLink()) {
+                return 'symbolic-link';
+            }
+            if (stat.isFile()) {
+                return 'file';
+            }
+            return stat.isDirectory() ? 'directory' : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    },
+    canExecute: (filePath) => {
+        try {
+            (0, node_fs_1.accessSync)(filePath, node_fs_1.constants.X_OK);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    },
+};
+const getExecutableCandidates = ({ executable, context, }) => {
+    var _a, _b;
+    const pathApi = context.platform === 'win32' ? node_path_1.default.win32 : node_path_1.default.posix;
+    const hasDirectory = pathApi.isAbsolute(executable) ||
+        executable.includes('/') ||
+        executable.includes('\\');
+    if (hasDirectory) {
+        return [
+            pathApi.isAbsolute(executable)
+                ? executable
+                : pathApi.resolve(context.currentWorkingDirectory, executable),
+        ];
+    }
+    const pathDirectories = ((_a = context.env.PATH) !== null && _a !== void 0 ? _a : '')
+        .split(context.platform === 'win32' ? ';' : ':')
+        .filter(Boolean);
+    if (context.platform !== 'win32') {
+        return pathDirectories.map((directory) => pathApi.join(directory, executable));
+    }
+    const currentExtension = node_path_1.default.win32.extname(executable).toLowerCase();
+    const extensions = currentExtension
+        ? ['']
+        : ((_b = context.env.PATHEXT) !== null && _b !== void 0 ? _b : '.COM;.EXE')
+            .split(';')
+            .map((extension) => extension.toLowerCase())
+            .filter((extension) => extension === '.com' || extension === '.exe');
+    return pathDirectories.flatMap((directory) => extensions.map((extension) => pathApi.join(directory, `${executable}${extension}`)));
+};
+const resolveCustomEditorExecutable = (editor, context = defaultResolutionContext) => {
+    for (const candidate of getExecutableCandidates({
+        executable: editor.executable,
+        context,
+    })) {
+        const pathType = context.inspectPath(candidate);
+        if (context.platform === 'darwin' &&
+            (pathType === 'directory' || pathType === 'symbolic-link') &&
+            candidate.toLowerCase().endsWith('.app')) {
+            return { executable: candidate, spawnAsMacApplication: true };
+        }
+        if (pathType !== 'file' && pathType !== 'symbolic-link') {
+            continue;
+        }
+        if (context.platform === 'win32') {
+            const extension = node_path_1.default.win32.extname(candidate).toLowerCase();
+            if (extension !== '.exe' && extension !== '.com') {
+                continue;
+            }
+        }
+        else if (!context.canExecute(candidate)) {
+            continue;
+        }
+        return { executable: candidate, spawnAsMacApplication: false };
+    }
+    return null;
+};
+exports.resolveCustomEditorExecutable = resolveCustomEditorExecutable;
+const normalizeCustomEditorTargetPath = ({ targetPath, platform, release, currentWorkingDirectory, }) => {
+    if (platform === 'linux' &&
+        targetPath.startsWith('/mnt/') &&
+        /Microsoft/i.test(release)) {
+        return node_path_1.default.posix.relative(currentWorkingDirectory, targetPath);
+    }
+    return targetPath;
+};
+exports.normalizeCustomEditorTargetPath = normalizeCustomEditorTargetPath;
+const expandCustomEditorArguments = ({ argumentTemplates, targetPath, lineNumber, columnNumber, }) => {
+    return argumentTemplates.map((argument) => argument
+        .replaceAll(renderer_1.customEditorTargetPathPlaceholder, targetPath)
+        .replaceAll(renderer_1.customEditorLineNumberPlaceholder, String(lineNumber))
+        .replaceAll(renderer_1.customEditorColumnNumberPlaceholder, String(columnNumber)));
+};
+exports.expandCustomEditorArguments = expandCustomEditorArguments;
+const launchCustomEditor = ({ editor, resolvedExecutable, targetPath, lineNumber, columnNumber, logLevel, spawnProcess, }) => {
+    if (!(0, node_fs_1.existsSync)(targetPath) ||
+        !Number.isInteger(lineNumber) ||
+        lineNumber <= 0) {
+        return Promise.resolve(false);
+    }
+    const safeColumnNumber = Number.isInteger(columnNumber) && columnNumber > 0 ? columnNumber : 1;
+    const normalizedTargetPath = (0, exports.normalizeCustomEditorTargetPath)({
+        targetPath,
+        platform: process.platform,
+        release: node_os_1.default.release(),
+        currentWorkingDirectory: process.cwd(),
+    });
+    const editorArguments = (0, exports.expandCustomEditorArguments)({
+        argumentTemplates: editor.arguments,
+        targetPath: normalizedTargetPath,
+        lineNumber,
+        columnNumber: safeColumnNumber,
+    });
+    const command = resolvedExecutable.spawnAsMacApplication
+        ? 'open'
+        : resolvedExecutable.executable;
+    const args = resolvedExecutable.spawnAsMacApplication
+        ? ['-a', resolvedExecutable.executable, ...editorArguments]
+        : editorArguments;
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = (spawnProcess !== null && spawnProcess !== void 0 ? spawnProcess : node_child_process_1.spawn)(command, args, {
+                detached: true,
+                shell: false,
+                stdio: 'ignore',
+            });
+        }
+        catch (error) {
+            renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, `Could not launch custom editor ${editor.name}:`, error);
+            resolve(false);
+            return;
+        }
+        child.once('error', (error) => {
+            renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, `Could not launch custom editor ${editor.name}:`, error);
+            resolve(false);
+        });
+        child.once('spawn', () => {
+            child.unref();
+            resolve(true);
+        });
+        child.on('exit', (exitCode) => {
+            if (exitCode) {
+                renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, `Custom editor ${editor.name} exited with code ${exitCode}.`);
+            }
+        });
+    });
+};
+exports.launchCustomEditor = launchCustomEditor;

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

@@ -0,0 +1,18 @@
+import type { BuiltInEditor } from '@remotion/renderer';
+export type InstalledEditor = {
+    id: BuiltInEditor;
+    name: string;
+    process: string;
+    command: string;
+};
+export type EditorDiscoveryContext = {
+    platform: NodeJS.Platform;
+    env: NodeJS.ProcessEnv;
+    homeDirectory: string;
+    pathExists: (filePath: string) => boolean;
+    findMacApplications: (bundleIdentifier: string) => Promise<readonly string[]>;
+    findWindowsApplications: (editor: BuiltInEditor) => Promise<readonly string[]>;
+};
+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[]>;