Termix/electron/preload.js

const { contextBridge, ipcRenderer, webFrame } = require("electron");

const ALLOWED_INVOKE_CHANNELS = new Set([
  "get-desktop-settings",
  "get-previous-server-url",
  "save-desktop-settings",
  "allow-invalid-certificate-for-origin",
]);

function invokeAllowed(channel, ...args) {
  if (!ALLOWED_INVOKE_CHANNELS.has(channel)) {
    return Promise.reject(new Error(`IPC channel is not allowed: ${channel}`));
  }
  return ipcRenderer.invoke(channel, ...args);
}

contextBridge.exposeInMainWorld("electronAPI", {
  getAppVersion: () => ipcRenderer.invoke("get-app-version"),
  // Kept so the interface size can reset a zoom an earlier build applied.
  setZoomFactor: (factor) => {
    const value = Number(factor);
    if (!Number.isFinite(value)) return;
    webFrame.setZoomFactor(Math.min(2, Math.max(0.5, value)));
  },
  getPlatform: () => ipcRenderer.invoke("get-platform"),
  getEmbeddedServerStatus: () =>
    ipcRenderer.invoke("get-embedded-server-status"),

  removeAllListeners: (channel) => ipcRenderer.removeAllListeners(channel),
  isElectron: true,
  isDev: process.env.NODE_ENV === "development",

  getSetting: (key) => ipcRenderer.invoke("get-setting", key),
  setSetting: (key, value) => ipcRenderer.invoke("set-setting", key, value),
  answerC2SAuth: (id, answer) =>
    ipcRenderer.invoke("answer-c2s-auth", id, answer),
  onC2SAuthPrompt: (callback) => {
    const listener = (_event, prompt) => callback(prompt);
    ipcRenderer.on("c2s-auth-prompt", listener);
    return () => ipcRenderer.removeListener("c2s-auth-prompt", listener);
  },
  getC2STunnelConfig: () => ipcRenderer.invoke("get-c2s-tunnel-config"),
  saveC2STunnelConfig: (config) =>
    ipcRenderer.invoke("save-c2s-tunnel-config", config),
  checkLocalPortAvailable: (host, port) =>
    ipcRenderer.invoke("check-local-port-available", host, port),
  getC2STunnelPresetDefaultName: () =>
    ipcRenderer.invoke("get-c2s-tunnel-preset-default-name"),
  startC2STunnel: (tunnel, index, authToken) =>
    ipcRenderer.invoke("start-c2s-tunnel", tunnel, index, authToken),
  testC2STunnel: (tunnel, index, authToken) =>
    ipcRenderer.invoke("test-c2s-tunnel", tunnel, index, authToken),
  stopC2STunnel: (tunnelName) =>
    ipcRenderer.invoke("stop-c2s-tunnel", tunnelName),
  getC2STunnelStatuses: () => ipcRenderer.invoke("get-c2s-tunnel-statuses"),
  onC2STunnelStatuses: (callback) => {
    const listener = (_event, statuses) => callback(statuses);
    ipcRenderer.on("c2s-tunnel-statuses", listener);
    return () => ipcRenderer.removeListener("c2s-tunnel-statuses", listener);
  },
  startC2SAutoStartTunnels: () =>
    ipcRenderer.invoke("start-c2s-autostart-tunnels"),
  setC2SRelayPath: (relayPath) =>
    ipcRenderer.invoke("set-c2s-relay-path", relayPath),

  onCloseActiveTab: (callback) => {
    const listener = () => callback();
    ipcRenderer.on("close-active-tab", listener);
    return () => ipcRenderer.removeListener("close-active-tab", listener);
  },

  clearSessionCookies: () => ipcRenderer.invoke("clear-session-cookies"),
  getSessionCookie: (name, targetUrl) =>
    ipcRenderer.invoke("get-session-cookie", name, targetUrl),
  waitForSessionCookie: (name, targetUrl, previousValue, timeoutMs) =>
    ipcRenderer.invoke(
      "wait-session-cookie",
      name,
      targetUrl,
      previousValue,
      timeoutMs,
    ),

  externalBrowserLogin: (authUrl, callbackPort) =>
    ipcRenderer.invoke("external-browser-login", authUrl, callbackPort),

  openExternalEditor: (fileData) =>
    ipcRenderer.invoke("open-external-editor", fileData),
  closeExternalEditor: (editId) =>
    ipcRenderer.invoke("close-external-editor", editId),
  onExternalEditorSaved: (callback) => {
    const listener = (_event, payload) => callback(payload);
    ipcRenderer.on("external-editor-saved", listener);
    return () => ipcRenderer.removeListener("external-editor-saved", listener);
  },

  showSaveDialog: (options) => ipcRenderer.invoke("show-save-dialog", options),
  showOpenDialog: (options) => ipcRenderer.invoke("show-open-dialog", options),
  getLocalHomeDirectory: () => ipcRenderer.invoke("get-local-home-directory"),
  listLocalDirectory: (dirPath) =>
    ipcRenderer.invoke("list-local-directory", dirPath),
  statLocalPaths: (paths) => ipcRenderer.invoke("stat-local-paths", paths),
  collectLocalFiles: (paths) =>
    ipcRenderer.invoke("collect-local-files", paths),
  createLocalFolder: (parentPath, folderName) =>
    ipcRenderer.invoke("create-local-folder", parentPath, folderName),
  renameLocalPath: (entryPath, newName) =>
    ipcRenderer.invoke("rename-local-path", entryPath, newName),
  trashLocalPath: (entryPath) =>
    ipcRenderer.invoke("trash-local-path", entryPath),
  chmodLocalPath: (entryPath, permissions) =>
    ipcRenderer.invoke("chmod-local-path", entryPath, permissions),
  createTempFile: (fileData) =>
    ipcRenderer.invoke("create-temp-file", fileData),
  createTempFolder: (folderData) =>
    ipcRenderer.invoke("create-temp-folder", folderData),
  startDragToDesktop: (dragData) =>
    ipcRenderer.invoke("start-drag-to-desktop", dragData),
  cleanupTempFile: (tempId) => ipcRenderer.invoke("cleanup-temp-file", tempId),

  startLocalTerminal: (dimensions) =>
    ipcRenderer.invoke("local-terminal-start", dimensions),
  writeLocalTerminal: (sessionId, data) =>
    ipcRenderer.invoke("local-terminal-write", sessionId, data),
  readyLocalTerminal: (sessionId) =>
    ipcRenderer.invoke("local-terminal-ready", sessionId),
  resizeLocalTerminal: (sessionId, cols, rows) =>
    ipcRenderer.invoke("local-terminal-resize", sessionId, cols, rows),
  closeLocalTerminal: (sessionId) =>
    ipcRenderer.invoke("local-terminal-close", sessionId),
  onLocalTerminalData: (sessionId, callback) => {
    const channel = `local-terminal:data:${sessionId}`;
    const listener = (_event, data) => callback(data);
    ipcRenderer.on(channel, listener);
    return () => ipcRenderer.removeListener(channel, listener);
  },
  onLocalTerminalExit: (sessionId, callback) => {
    const channel = `local-terminal:exit:${sessionId}`;
    const listener = (_event, exitCode) => callback(exitCode);
    ipcRenderer.on(channel, listener);
    return () => ipcRenderer.removeListener(channel, listener);
  },

  // Dual-pane file manager: local disk browsing and streamed transfers.
  localFs: {
    home: () => ipcRenderer.invoke("local-fs:home"),
    list: (dirPath) => ipcRenderer.invoke("local-fs:list", dirPath),
    mkdir: (parentPath, name) =>
      ipcRenderer.invoke("local-fs:mkdir", parentPath, name),
    createFile: (parentPath, name) =>
      ipcRenderer.invoke("local-fs:create-file", parentPath, name),
    rename: (oldPath, newName) =>
      ipcRenderer.invoke("local-fs:rename", oldPath, newName),
    trash: (paths) => ipcRenderer.invoke("local-fs:trash", paths),
    ensureDir: (dirPath, rootPath) =>
      ipcRenderer.invoke("local-fs:ensure-dir", dirPath, rootPath),
    exists: (paths) => ipcRenderer.invoke("local-fs:exists", paths),
    walk: (paths) => ipcRenderer.invoke("local-fs:walk", paths),
    reveal: (targetPath) => ipcRenderer.invoke("local-fs:reveal", targetPath),
    open: (targetPath) => ipcRenderer.invoke("local-fs:open", targetPath),
  },
  localTransfer: {
    setApiPath: (apiPath) =>
      ipcRenderer.invoke("local-transfer:set-api", apiPath),
    upload: (options) => ipcRenderer.invoke("local-transfer:upload", options),
    download: (options) =>
      ipcRenderer.invoke("local-transfer:download", options),
    cancel: (transferId) =>
      ipcRenderer.invoke("local-transfer:cancel", transferId),
    onProgress: (callback) => {
      const listener = (_event, payload) => callback(payload);
      ipcRenderer.on("local-transfer:progress", listener);
      return () =>
        ipcRenderer.removeListener("local-transfer:progress", listener);
    },
  },

  invoke: invokeAllowed,
});

contextBridge.exposeInMainWorld("electronClipboard", {
  writeText: (text) => ipcRenderer.invoke("clipboard-write-text", text),
  readText: () => ipcRenderer.invoke("clipboard-read-text"),
});

window.IS_ELECTRON = true;