super-productivity/electron/preload.ts

import { ipcRenderer, webFrame, contextBridge, webUtils } from 'electron';
import { ElectronAPI } from './electronAPI.d';
import { IS_GNOME_DESKTOP, IS_GNOME_WAYLAND } from './common.const';
import { IPC, IPCEventValue } from './shared-with-frontend/ipc-events.const';
import {
  getDistChannel,
  ElectronDistChannel,
} from './shared-with-frontend/get-dist-channel';
import { LocalBackupMeta } from '../src/app/imex/local-backup/local-backup.model';
import {
  PluginNodeScriptRequest,
  PluginNodeScriptResult,
} from '../packages/plugin-api/src/types';
import {
  LocalRestApiRequestPayload,
  LocalRestApiResponsePayload,
} from './shared-with-frontend/local-rest-api.model';
import {
  createJiraPreloadApiConsumer,
  toPayloadOnlyIpcListener,
} from './shared-with-frontend/preload-api';

let pluginNodeExecutionApiConsumed = false;

const _send: (channel: IPCEventValue, ...args: unknown[]) => void = (channel, ...args) =>
  ipcRenderer.send(channel, ...args);
const _invoke: (channel: IPCEventValue, ...args: unknown[]) => Promise<unknown> = (
  channel,
  ...args
) => ipcRenderer.invoke(channel, ...args);

const consumeJiraApi = createJiraPreloadApiConsumer(_invoke);

const ea: ElectronAPI = {
  on: (channel: string, listener: (...args: unknown[]) => void) => {
    // NOTE: there is no proper way to unsubscribe apart from unsubscribing all
    ipcRenderer.on(channel, toPayloadOnlyIpcListener(listener));
  },
  // SYNC
  // ----
  getDistChannel: (): ElectronDistChannel | null => getDistChannel(),

  // INVOKE
  // ------
  getUserDataPath: () => _invoke('GET_PATH', 'userData') as Promise<string>,
  getBackupPath: () => _invoke('GET_BACKUP_PATH') as Promise<string>,
  checkBackupAvailable: () =>
    _invoke('BACKUP_IS_AVAILABLE') as Promise<false | LocalBackupMeta>,
  loadBackupData: (backupPath) =>
    _invoke('BACKUP_LOAD_DATA', backupPath) as Promise<string>,
  fileSyncSave: (args) => _invoke('FILE_SYNC_SAVE', args) as Promise<string | Error>,
  fileSyncLoad: (args) =>
    _invoke('FILE_SYNC_LOAD', args) as Promise<{
      rev: string;
      dataStr: string | undefined;
    }>,
  fileSyncRemove: (args) => _invoke('FILE_SYNC_REMOVE', args) as Promise<void>,
  fileSyncListFiles: (args) =>
    _invoke('FILE_SYNC_LIST_FILES', args) as Promise<string[] | Error>,
  checkDirExists: (args) => _invoke('CHECK_DIR_EXISTS', args) as Promise<true | Error>,

  pickDirectory: () => _invoke('PICK_DIRECTORY') as Promise<string | Error | undefined>,
  commitPickedDirectory: () =>
    _invoke('COMMIT_PICKED_DIRECTORY') as Promise<
      { path: string; isChanged: boolean } | null | Error
    >,
  discardPickedDirectory: () => _invoke('DISCARD_PICKED_DIRECTORY') as Promise<void>,
  getSyncFolderPath: () => _invoke('GET_SYNC_FOLDER_PATH') as Promise<string | null>,

  showOpenDialog: (options: {
    properties: string[];
    title?: string;
    defaultPath?: string;
    filters?: { name: string; extensions: string[] }[];
  }) => _invoke('SHOW_OPEN_DIALOG', options) as Promise<string[] | undefined>,

  imagePickAndImport: () =>
    _invoke('IMAGE_PICK_AND_IMPORT') as Promise<
      | {
          id: string;
          mimeType: string;
        }
      | null
      | Error
    >,
  imageCacheGetDataUrl: (id: string) =>
    _invoke('IMAGE_CACHE_GET_DATA_URL', id) as Promise<string | null>,
  // STANDARD
  // --------
  setZoomFactor: (zoomFactor: number) => {
    webFrame.setZoomFactor(zoomFactor);
  },
  getZoomFactor: () => webFrame.getZoomFactor(),
  isLinux: () => process.platform === 'linux',
  isGnomeDesktop: () => IS_GNOME_DESKTOP,
  isGnomeWayland: () => IS_GNOME_WAYLAND,
  isMacOS: () => process.platform === 'darwin',
  isAppleSilicon: () => process.platform === 'darwin' && process.arch === 'arm64',
  isSnap: () => process && process.env && !!process.env.SNAP,
  isFlatpak: () => process && process.env && !!process.env.FLATPAK_ID,

  // CLIPBOARD IMAGES
  // ----------------
  saveClipboardImage: (
    basePath: string,
    fileName: string,
    base64Data: string,
    mimeType: string,
  ) =>
    _invoke('CLIPBOARD_IMAGE_SAVE', {
      basePath,
      fileName,
      base64Data,
      mimeType,
    }) as Promise<string>,

  loadClipboardImage: (basePath: string, imageId: string) =>
    _invoke('CLIPBOARD_IMAGE_LOAD', { basePath, imageId }) as Promise<{
      base64: string;
      mimeType: string;
    } | null>,

  deleteClipboardImage: (basePath: string, imageId: string) =>
    _invoke('CLIPBOARD_IMAGE_DELETE', { basePath, imageId }) as Promise<boolean>,

  listClipboardImages: (basePath: string) =>
    _invoke('CLIPBOARD_IMAGE_LIST', { basePath }) as Promise<
      { id: string; mimeType: string; createdAt: number; size: number }[]
    >,

  getClipboardImagePath: (basePath: string, imageId: string) =>
    _invoke('CLIPBOARD_IMAGE_GET_PATH', { basePath, imageId }) as Promise<string | null>,

  getClipboardFilePaths: () => _invoke('CLIPBOARD_GET_FILE_PATHS') as Promise<string[]>,

  copyClipboardImageFile: (basePath: string, filePath: string) =>
    _invoke('CLIPBOARD_COPY_IMAGE_FILE', {
      basePath,
      filePath,
    }) as Promise<{
      id: string;
      mimeType: string;
      size: number;
      createdAt: number;
    } | null>,

  readClipboardImage: (basePath: string) =>
    _invoke('CLIPBOARD_READ_IMAGE', { basePath }) as Promise<{
      id: string;
      mimeType: string;
      size: number;
      createdAt: number;
    } | null>,

  getPathForFile: (file: File) => {
    try {
      return webUtils.getPathForFile(file);
    } catch (error) {
      console.error('[CLIPBOARD] Error getting path for file:', error);
      return null;
    }
  },

  // SEND
  // ----
  relaunch: () => _send('RELAUNCH'),
  exit: () => _send('EXIT'),
  flashFrame: () => _send('FLASH_FRAME'),
  showOrFocus: () => _send('SHOW_OR_FOCUS'),
  lockScreen: () => _send('LOCK_SCREEN'),
  shutdownNow: () => _send('SHUTDOWN_NOW'),
  reloadMainWin: () => _send('RELOAD_MAIN_WIN'),
  openDevTools: () => _send('OPEN_DEV_TOOLS'),
  showEmojiPanel: () => _send('SHOW_EMOJI_PANEL'),
  informAboutAppReady: () => _send('APP_READY'),

  openPath: (path: string) => _send('OPEN_PATH', path),
  openExternalUrl: (url: string) => _send('OPEN_EXTERNAL', url),
  saveFileDialog: (filename: string, data: string) =>
    _invoke('SAVE_FILE_DIALOG', { filename, data }) as Promise<{
      success: boolean;
      path?: string;
    }>,
  shareNative: (payload: {
    text?: string;
    url?: string;
    title?: string;
    files?: string[];
  }) =>
    _invoke('SHARE_NATIVE', payload) as Promise<{
      success: boolean;
      error?: string;
    }>,
  scheduleRegisterBeforeClose: (id) => _send('REGISTER_BEFORE_CLOSE', { id }),
  unscheduleRegisterBeforeClose: (id) => _send('UNREGISTER_BEFORE_CLOSE', { id }),
  setDoneRegisterBeforeClose: (id) => _send('BEFORE_CLOSE_DONE', { id }),

  setProgressBar: (args) => _send('SET_PROGRESS_BAR', args),

  sendAppSettingsToElectron: (globalCfg) =>
    _send('TRANSFER_SETTINGS_TO_ELECTRON', globalCfg),
  sendSettingsUpdate: (globalCfg) => _send('UPDATE_SETTINGS', globalCfg),
  updateTaskWidgetSettings: (cfg) => _send('UPDATE_TASK_WIDGET_SETTINGS', cfg),
  updateTitleBarDarkMode: (isDarkMode: boolean) =>
    _send('UPDATE_TITLE_BAR_DARK_MODE', isDarkMode),
  registerGlobalShortcuts: (keyboardCfg) =>
    _send('REGISTER_GLOBAL_SHORTCUTS', keyboardCfg),
  showFullScreenBlocker: (args) => _send('FULL_SCREEN_BLOCKER', args),

  backupAppData: (appData) => _send('BACKUP', appData),

  updateCurrentTask: (
    task,
    isPomodoroEnabled,
    currentPomodoroSessionTime,
    isFocusModeEnabled?,
    currentFocusSessionTime?,
    focusModeMode?,
  ) =>
    _send(
      'CURRENT_TASK_UPDATED',
      task,
      isPomodoroEnabled,
      currentPomodoroSessionTime,
      isFocusModeEnabled,
      currentFocusSessionTime,
      focusModeMode,
    ),

  updateTodayTasks: (tasks: any[]) => _send('TODAY_TASKS_UPDATED', tasks),

  onSwitchTask: (listener: (taskId: string) => void) => {
    // We register the listener directly without using standard 'on' method
    // Because the standard 'on' method doesn't strip out the event arg like we need
    ipcRenderer.on('SWITCH_TASK', (_: any, taskId: string) => listener(taskId));
  },

  consumeJiraApi: () => consumeJiraApi(),

  // Plugin API
  consumePluginNodeExecutionApi: () => {
    if (pluginNodeExecutionApiConsumed) {
      return null;
    }
    pluginNodeExecutionApiConsumed = true;
    return {
      requestGrant: (
        pluginId: string,
        displayInfo?: { name?: string; version?: string },
      ) =>
        _invoke('PLUGIN_REQUEST_NODE_EXECUTION_GRANT', pluginId, displayInfo) as Promise<{
          token: string;
        } | null>,
      executeScript: (
        pluginId: string,
        grantToken: string,
        request: PluginNodeScriptRequest,
      ) =>
        _invoke(
          'PLUGIN_EXEC_NODE_SCRIPT',
          pluginId,
          grantToken,
          request,
        ) as Promise<PluginNodeScriptResult>,
      revokeGrant: (pluginId: string, grantToken: string) =>
        _invoke(
          'PLUGIN_REVOKE_NODE_EXECUTION_GRANT',
          pluginId,
          grantToken,
        ) as Promise<void>,
      clearConsent: (pluginId: string) =>
        _invoke('PLUGIN_CLEAR_NODE_EXECUTION_CONSENT', pluginId) as Promise<void>,
    };
  },

  // Plugin OAuth
  pluginOAuthPrepare: (port?: number) =>
    _invoke('PLUGIN_OAUTH_PREPARE', port) as Promise<{ port: number }>,
  pluginOAuthStart: (url: string) => _send('PLUGIN_OAUTH_START', { url }),
  onPluginOAuthCb: (
    listener: (data: { code?: string; error?: string; state?: string }) => void,
  ) => {
    ipcRenderer.on(
      IPC.PLUGIN_OAUTH_CB,
      (_: unknown, data: { code?: string; error?: string; state?: string }) =>
        listener(data),
    );
  },

  onLocalRestApiRequest: (listener: (payload: LocalRestApiRequestPayload) => void) => {
    ipcRenderer.on(IPC.LOCAL_REST_API_REQUEST, (_event, payload) =>
      listener(payload as LocalRestApiRequestPayload),
    );
  },
  sendLocalRestApiResponse: (payload: LocalRestApiResponsePayload) =>
    _send(IPC.LOCAL_REST_API_RESPONSE, payload),
};

// Expose ea to window for ipc-event.ts using contextBridge for context isolation
contextBridge.exposeInMainWorld('ea', ea);