The swiss army knife of lossless video/audio editing
process.traceDeprecation = true;
process.traceProcessWarnings = true;
/* eslint-disable import/first */
// eslint-disable-next-line import-js/no-extraneous-dependencies
import electron, { BrowserWindow, nativeTheme, shell, app, ipcMain, Notification } from 'electron';
import type { BrowserWindowConstructorOptions, NotificationConstructorOptions } from 'electron';
import i18n from 'i18next';
// eslint-disable-next-line import-js/no-extraneous-dependencies
import debounce from 'lodash/debounce.js';
import yargsParser from 'yargs-parser';
import JSON5 from 'json5';
import remote from '@electron/remote/main/index.js';
import { readFile, stat } from 'node:fs/promises';
import { join } from 'node:path';
import assert from 'node:assert';
import timers from 'node:timers/promises';
import { z } from 'zod';
import { fileURLToPath, pathToFileURL } from 'node:url';
import electronUnhandled from 'electron-unhandled';
import { fileTypeFromFile } from 'file-type';
import type { Asyncify } from 'type-fest';
// eslint-disable-next-line import-js/no-extraneous-dependencies
import { downloadChromeExtension } from 'electron-devtools-installer/dist/downloadChromeExtension.js';
import mitt from 'mitt';
import logger from './logger.js';
import menu from './menu.js';
import * as configStore from './configStore.js';
import { isLinux, isWindows, isMac, platform, arch, pathExists, resolveCliFileArgs, parseCliKeyboardActionArgs, parseSettingsJson } from './util.js';
import { appName } from './common.js';
import attachContextMenu from './contextMenu.js';
import HttpServer from './httpServer.js';
import isDev from './isDev.js';
import isStoreBuild from './isStoreBuild.js';
import { getAboutPanelOptions } from './aboutPanel.js';
import { checkNewVersion } from './updateChecker.js';
import * as i18nCommon from './i18nCommon.js';
import './i18n.js';
import type { ApiActionRequest, Config } from '../common/types.js';
import * as ffmpeg from './ffmpeg.js';
import * as compatPlayer from './compatPlayer.js';
import { downloadMediaUrl } from './ffmpeg.js';
import { hasDisabledNetworking, setDisableNetworking } from './networking.js';
electronUnhandled({ showDialog: true, logger: (err) => logger.error('electron-unhandled', err) });
// https://chromestatus.com/feature/5748496434987008
// https://peter.sh/experiments/chromium-command-line-switches/
// https://chromium.googlesource.com/chromium/src/+/main/third_party/blink/renderer/platform/runtime_enabled_features.json5
app.commandLine.appendSwitch('enable-blink-features', 'AudioVideoTracks');
// OS media keys / media session don't work properly with our player (play only a single frame), so disable them https://github.com/mifi/lossless-cut/issues/3028
// appendSwitch replaces any existing value, e.g. one passed on the command line, so keep it
app.commandLine.appendSwitch('disable-features', [app.commandLine.getSwitchValue('disable-features'), 'HardwareMediaKeyHandling', 'MediaSessionService'].filter(Boolean).join(','));
remote.initialize();
app.name = appName;
if (isWindows) {
// in order to set the title on OS notifications on Windows, this needs to be set to app.name
// https://github.com/mifi/lossless-cut/pull/2139
// https://stackoverflow.com/a/65863174/6519037
app.setAppUserModelId(app.name);
}
let filesToOpen: string[] = [];
// Keep a global reference of the window object, if you don't, the window will
// be closed automatically when the JavaScript object is garbage collected.
let mainWindow: BrowserWindow | null;
let askBeforeClose = false;
let rendererReady = false;
let newVersion: string | undefined;
const openFiles = (paths: string[]) => mainWindow!.webContents.send('openFiles', paths);
let apiActionRequestsId = 0;
const apiActionRequests = new Map<number, () => void>();
// Not using installExtension from electron-devtools-installer because it calls deprecated Electron session APIs
async function installReactDevTools() {
const id = 'fmkadmapgofadopljbjfkapdkoienihi';
let extensionFolder = await downloadChromeExtension(id);
// The downloaded copy is cached forever, so replace it if it's an old Manifest V2 build
const { manifest_version: manifestVersion } = JSON.parse(await readFile(join(extensionFolder, 'manifest.json'), 'utf8'));
if (manifestVersion < 3) extensionFolder = await downloadChromeExtension(id, { forceDownload: true });
return electron.session.defaultSession.extensions.loadExtension(extensionFolder);
}
async function sendApiAction(action: string, args?: unknown[]) {
try {
const id = apiActionRequestsId;
apiActionRequestsId += 1;
mainWindow!.webContents.send('apiAction', { id, action, args } satisfies ApiActionRequest);
await new Promise<void>((resolve) => { apiActionRequests.set(id, resolve); });
} catch (err) {
logger.error('sendApiAction', err);
}
}
export type AppEvent = {
eventName: 'export-complete',
paths?: string[],
} | {
eventName: 'export-start',
path: string,
};
const appEventEmitter = mitt<{ appEvent: AppEvent }>();
ipcMain.on('appEvent', (_e, appEvent: AppEvent) => {
appEventEmitter.emit('appEvent', appEvent);
});
async function onAwaitAppEvent(awaitEventName: string, signal: AbortSignal) {
return new Promise<AppEvent>((resolve, reject) => {
const handler = (appEvent: AppEvent) => {
if (appEvent.eventName === awaitEventName) {
appEventEmitter.off('appEvent', handler);
resolve(appEvent);
}
};
appEventEmitter.on('appEvent', handler);
signal.addEventListener('abort', () => {
appEventEmitter.off('appEvent', handler);
reject(new Error('Aborted'));
});
});
}
// https://github.com/electron/electron/issues/526#issuecomment-563010533
function getSavedBounds() {
const bounds = configStore.get('windowBounds');
const options: BrowserWindowConstructorOptions = {};
if (bounds) {
const area = electron.screen.getDisplayMatching(bounds).workArea;
// If the saved position still valid (the window is entirely inside the display area), use it.
if (
bounds.x >= area.x
&& bounds.y >= area.y
&& bounds.x + bounds.width <= area.x + area.width
&& bounds.y + bounds.height <= area.y + area.height
) {
options.x = bounds.x;
options.y = bounds.y;
}
// If the saved size is still valid, use it.
if (bounds.width <= area.width || bounds.height <= area.height) {
options.width = bounds.width;
options.height = bounds.height;
}
}
return {
options,
isMaximized: bounds != null ? bounds.isMaximized : false,
};
}
const getBackgroundColor = () => (nativeTheme.shouldUseDarkColors ? '#333' : '#fff');
function createWindow() {
const savedBounds = getSavedBounds();
mainWindow = new BrowserWindow({
...savedBounds.options,
darkTheme: true,
webPreferences: {
contextIsolation: false,
nodeIntegration: true,
// https://github.com/electron/electron/issues/5107
webSecurity: !isDev,
preload: fileURLToPath(new URL('../preload/index.cjs', import.meta.url)),
},
backgroundColor: getBackgroundColor(),
minWidth: 300,
minHeight: 300,
});
if (savedBounds.isMaximized) mainWindow.maximize();
remote.enable(mainWindow.webContents);
attachContextMenu(mainWindow);
if (isDev) mainWindow.loadURL('http://localhost:3001');
// Need to useloadFile for special characters https://github.com/mifi/lossless-cut/issues/40
else mainWindow.loadFile('out/renderer/index.html');
// Open the DevTools.
// mainWindow.webContents.openDevTools()
// Emitted when the window is closed.
mainWindow.on('closed', () => {
// Dereference the window object, usually you would store windows
// in an array if your app supports multi windows, this is the time
// when you should delete the corresponding element.
mainWindow = null;
});
// https://stackoverflow.com/questions/39574636/prompt-to-save-quit-before-closing-window/47434365
mainWindow.on('close', (e) => {
if (!askBeforeClose) return;
assert.ok(mainWindow);
const choice = electron.dialog.showMessageBoxSync(mainWindow, {
type: 'question',
buttons: ['Yes', 'No'],
title: i18n.t('Confirm quit'),
message: i18n.t('Are you sure you want to quit?'),
});
if (choice === 1) {
e.preventDefault();
}
});
// TODO replace with `windowStatePersistence` in the future? https://github.com/electron/rfcs/pull/16
const debouncedSaveWindowState = debounce(() => {
if (!mainWindow || !configStore.get('storeWindowBounds')) return;
const { x, y, width, height } = mainWindow.getNormalBounds();
const isMaximized = mainWindow.isMaximized();
configStore.set('windowBounds', { x, y, width, height, isMaximized });
}, 500);
mainWindow.on('maximize', debouncedSaveWindowState);
mainWindow.on('unmaximize', debouncedSaveWindowState);
mainWindow.on('resize', debouncedSaveWindowState);
mainWindow.on('move', debouncedSaveWindowState);
}
async function openExternal(url: string) {
if (hasDisabledNetworking()) {
logger.warn('openExternal blocked because networking is disabled', url);
return;
}
await shell.openExternal(url);
}
function updateMenu() {
assert.ok(mainWindow);
menu({ app, mainWindow, newVersion, isStoreBuild, openExternal });
}
async function changeLanguage(language: string | null) {
try {
await i18n.changeLanguage(language ?? undefined);
updateMenu();
// https://www.electronjs.org/docs/latest/api/app#appsetaboutpaneloptionsoptions
app.setAboutPanelOptions(getAboutPanelOptions());
} catch (err) {
logger.error('Failed to set language', err);
}
}
function openFilesEventually(paths: string[]) {
if (rendererReady) openFiles(paths);
else filesToOpen = paths;
}
// https://github.com/electron/electron/issues/3657
// https://github.com/mifi/lossless-cut/issues/357
// https://github.com/mifi/lossless-cut/issues/639
// https://github.com/mifi/lossless-cut/issues/591
function parseCliArgs(rawArgv = process.argv) {
const ignoreFirstArgs = process.defaultApp ? 2 : 1;
// production: First arg is the LosslessCut executable
// dev: First 2 args are electron and the index.js
const argsWithoutAppName = rawArgv.length > ignoreFirstArgs ? rawArgv.slice(ignoreFirstArgs) : [];
return yargsParser(argsWithoutAppName, {
boolean: ['disable-networking'],
string: ['settings-json', 'config-dir', 'lossy-mode', 'keyboard-action'],
});
}
const argv = parseCliArgs();
const lossyModeSchema = z.object({ videoEncoder: z.union([z.literal('libx264'), z.literal('libx265'), z.literal('libsvtav1')]) });
const lossyMode = argv['lossyMode'] ? lossyModeSchema.parse(JSON5.parse(argv['lossyMode'])) : undefined;
export type LossyMode = z.infer<typeof lossyModeSchema>;
if (argv['localesPath'] != null) i18nCommon.setCustomLocalesPath(argv['localesPath']);
function safeRequestSingleInstanceLock(additionalData: Record<string, unknown>) {
if (process.mas) return true; // todo remove when dropping support for MacOS 13 https://github.com/electron/electron/issues/35540#issuecomment-2173130321
// using additionalData because the built in "argv" passing is a bit broken:
// https://github.com/electron/electron/issues/20322
return app.requestSingleInstanceLock(additionalData);
}
// This promise will be fulfilled when Electron has finished
// initialization and is ready to create browser windows.
// Some APIs can only be used after this event occurs.
// Call this immediately, to make sure we don't miss it (race condition)
const readyPromise = app.whenReady();
async function init() {
try {
logger.info('LosslessCut version', app.getVersion(), { isDev });
await configStore.init({ customConfigDir: argv['configDir'] });
logger.info('Initialized config store');
const allowMultipleInstances = configStore.get('allowMultipleInstances');
const language = configStore.get('language');
if (!allowMultipleInstances && !safeRequestSingleInstanceLock({ argv: process.argv })) {
logger.info('Found running instance, quitting');
app.quit();
return;
}
// On macOS, the system enforces single instance automatically when users try to open a second instance of your app in Finder, and the open-file and open-url events will be emitted for that.
// However when users start your app in command line, the system's single instance mechanism will be bypassed, and you have to use this method to ensure single instance.
// This can be tested with one terminal: npx electron .
// and another terminal: npx electron . path/to/file.mp4
app.on('second-instance', (_event, _commandLine, workingDirectory, additionalData) => {
// Someone tried to run a second instance, we should focus our window.
if (mainWindow) {
if (mainWindow.isMinimized()) mainWindow.restore();
mainWindow.focus();
}
const parsedAdditionalData = z.object({ argv: z.string().array() }).safeParse(additionalData);
if (!parsedAdditionalData.success) return;
const argv2 = parseCliArgs(parsedAdditionalData.data.argv);
logger.info('second-instance', argv2);
const { keyboardAction } = argv2;
if (keyboardAction) {
try {
sendApiAction(keyboardAction, parseCliKeyboardActionArgs(keyboardAction, argv2._, workingDirectory));
} catch (err) {
logger.error('Invalid --keyboard-action arguments', err);
}
} else if (argv2._ && argv2._.length > 0) openFilesEventually(resolveCliFileArgs(argv2._.map(String), workingDirectory));
});
// Quit when all windows are closed.
app.on('window-all-closed', () => {
app.quit();
});
app.on('activate', () => {
// On OS X it's common to re-create a window in the app when the
// dock icon is clicked and there are no other windows open.
if (mainWindow === null) {
createWindow();
}
});
ipcMain.on('renderer-ready', () => {
rendererReady = true;
if (filesToOpen.length > 0) openFiles(filesToOpen);
});
// Mac OS open with LosslessCut
// Emitted when the user wants to open a file with the application. The open-file event is usually emitted when the application is already open and the OS wants to reuse the application to open the file.
app.on('open-file', (event, path) => {
openFilesEventually([path]);
event.preventDefault(); // recommended in docs https://www.electronjs.org/docs/latest/api/app#event-open-file-macos
});
ipcMain.on('setAskBeforeClose', (_e, val) => {
askBeforeClose = val;
});
ipcMain.on('setLanguage', (_e, newLanguage) => changeLanguage(newLanguage));
ipcMain.handle('tryTrashItem', async (_e, path) => {
try {
await stat(path);
} catch (err) {
if (err instanceof Error && 'code' in err && err.code === 'ENOENT') return;
}
await shell.trashItem(path);
});
ipcMain.handle('showItemInFolder', (_e, path) => shell.showItemInFolder(path));
ipcMain.on('apiActionResponse', (_e, { id }) => {
apiActionRequests.get(id)?.();
});
logger.info('Waiting for app to become ready');
await readyPromise;
// https://www.electronjs.org/docs/latest/tutorial/dark-mode
// also affects what `prefers-color-scheme` reports in the renderer
nativeTheme.themeSource = configStore.get('theme');
configStore.onDidChange('theme', (theme) => { nativeTheme.themeSource = theme; });
nativeTheme.on('updated', () => mainWindow?.setBackgroundColor(getBackgroundColor()));
logger.info('CLI arguments', argv);
if (argv['keyboardAction']) logger.warn('--keyboard-action only works with an already running instance (and "Allow multiple instances" disabled), ignoring it and its arguments');
// Only if no files to open already (open-file might have already added some files)
else if (filesToOpen.length === 0) filesToOpen = argv._.map(String);
const { settingsJson } = argv;
setDisableNetworking(argv['disableNetworking']);
if (settingsJson != null) {
logger.info('initializing settings', settingsJson);
const settings = parseSettingsJson(settingsJson);
if (settings.success) Object.entries(settings.data).forEach(([key, value]) => configStore.set(key as keyof Config, value));
else logger.error('Invalid --settings-json, ignoring it', z.prettifyError(settings.error));
}
const { httpApi } = argv;
if (httpApi != null) {
const port = typeof httpApi === 'number' ? httpApi : 8080;
const { startHttpServer } = HttpServer({ port, onKeyboardAction: sendApiAction, onAwaitAppEvent });
await startHttpServer();
logger.info('HTTP API listening on port', port);
}
if (isDev) {
// eslint-disable-next-line @typescript-eslint/no-var-requires,global-require,import-js/no-extraneous-dependencies
installReactDevTools()
.then((extension) => logger.info('Added Extension', extension.name))
.catch((err: unknown) => logger.error('Failed to add extension', err));
}
createWindow();
// will also updateMenu and set about panel options
await changeLanguage(language);
const enableUpdateCheck = configStore.get('enableUpdateCheck');
if (!hasDisabledNetworking() && enableUpdateCheck && !isStoreBuild) {
newVersion = await checkNewVersion();
// newVersion = '1.2.3';
if (newVersion) updateMenu();
}
} catch (err) {
logger.error('Failed to initialize', err);
}
}
function focusWindow() {
try {
app.focus({ steal: true });
} catch (err) {
logger.error('Failed to focus window', err);
}
}
function quitApp() {
// allow HTTP API to respond etc.
timers.setTimeout(1000).then(() => electron.app.quit());
}
const setProgressBar = (v: number) => mainWindow?.setProgressBar(v);
function sendOsNotification(options: NotificationConstructorOptions) {
if (!Notification.isSupported()) return;
const notification = new Notification(options);
// Note: For notifications on macOS, your application will need to be code-signed in order for notification events to emit correctly. This requirement stems from the underlying UNNotification API provided by Apple. Unsigned binaries will emit a `failed` event when notification APIs are called.
// https://www.electronjs.org/docs/latest/tutorial/notifications#macos
notification.on('failed', (_e, error) => logger.warn('Notification failed', error));
notification.show();
}
const remoteApi = {
pathExists,
downloadMediaUrl,
fileTypeFromFile,
focusWindow,
quitApp,
setProgressBar,
sendOsNotification,
writeClipboardText: (text: string) => electron.clipboard.writeText(text),
readClipboardText: () => electron.clipboard.readText(),
openExternal,
};
export type RemoteApi = typeof remoteApi;
export type RemoteRpcApi = {
[K in keyof RemoteApi]: Asyncify<RemoteApi[K]>;
};
// using @electron/remote
const remoteApiLegacy = {
ffmpeg,
i18n: i18nCommon,
compatPlayer,
configStore,
isLinux,
isWindows,
isMac,
platform,
arch,
isDev,
lossyMode,
pathToFileURL,
hasDisabledNetworking,
};
export type RemoteApiLegacy = typeof remoteApiLegacy;
// @ts-expect-error don't know how to type
app.addListener('remote-require', (event: { returnValue: RemoteApiLegacy }, _webContents: unknown, moduleName: string) => {
if (moduleName === './index.js') {
// eslint-disable-next-line no-param-reassign
event.returnValue = remoteApiLegacy;
}
});
// eslint-disable-next-line @typescript-eslint/no-explicit-any
ipcMain.handle('__electron_rpc__', async (_event, method: keyof RemoteApi, args: any[]) => {
const fn = remoteApi[method];
assert.ok(fn, `Unknown API method: ${method}`);
// @ts-expect-error don't know how to type
return fn(...args);
});
// cannot top level await because app.whenReady will hang forever
// eslint-disable-next-line unicorn/prefer-top-level-await
init();