index.ts

/**
 * Main process of the Electron application.
 */
import { app, BrowserWindow, nativeTheme, session } from 'electron';
import * as path from 'path';
import Pluto from './pluto';
import './baseEventListeners.ts';
import { initGlobals, startup } from './startup.ts';
import { generalLogger } from './logger.ts';
import { GlobalWindowManager } from './windowHelpers.ts';
import { Globals } from './globals.ts';
import { getAssetPath } from './paths.ts';
import { firstNotebookPath, isExtMatch, withSearchParams } from './util.ts';
import { initializeAutoUpdates } from './updater.ts';
import { handleSquirrelFileAssociations } from './fileAssociations.ts';

// This allows TypeScript to pick up the magic constants that's auto-generated by Forge's Webpack
// plugin that tells the Electron app where to look for the Webpack-bundled app code (depending on
// whether you're running in development or production).
declare const MAIN_WINDOW_WEBPACK_ENTRY: string;
declare const MAIN_WINDOW_PRELOAD_WEBPACK_ENTRY: string;

// On a Squirrel install/update/uninstall run, (un)register our .jl "Open with"
// file associations. This is a no-op on normal launches and on non-Windows.
handleSquirrelFileAssociations();

// Handle creating/removing shortcuts on Windows when installing/uninstalling.
if (require('electron-squirrel-startup')) {
  app.quit();
} else if (!app.requestSingleInstanceLock()) {
  // Another instance already owns the lock. Electron hands our argv (which may
  // contain a .jl path from a double-click) to that instance via the
  // 'second-instance' event below, so this one can just quit.
  app.quit();
} else {
  // Check for new releases on GitHub (via update.electronjs.org), download them
  // in the background, and prompt the user to restart. No-op during development.
  initializeAutoUpdates();

  // A second launch — e.g. double-clicking a notebook while Pluto is already
  // running — is routed here instead of spawning a new Julia server.
  app.on('second-instance', (_event, argv) => {
    const notebookPath = firstNotebookPath(argv);
    if (notebookPath) {
      void openExternalNotebook(notebookPath);
    } else {
      focusAnyWindow();
    }
  });
}

/**
 * Create a new BrowserWindow and attach a Pluto instance to it.
 * Returns the Pluto instance. Exported so the menu can spawn new windows.
 */
export const createPlutoWindow = (landingUrl?: string | null): Pluto => {
  const win = new BrowserWindow({
    title: 'Pluto.jl',
    height: 800,
    width: 700,
    resizable: true,
    show: true,
    backgroundColor: nativeTheme.shouldUseDarkColors ? '#1F1F1F' : 'white',
    icon: getAssetPath('icon.png'),
    webPreferences: {
      preload: MAIN_WINDOW_PRELOAD_WEBPACK_ENTRY,
      sandbox: false,
    },
  });

  const defaultLandingUrl = Globals.PLUTO_STARTED
    ? Pluto.resolveHtmlPath('index.html')
    : MAIN_WINDOW_WEBPACK_ENTRY;
  const pluto = new Pluto(
    win,
    landingUrl === undefined ? defaultLandingUrl : landingUrl,
  );
  win.focus();

  win.webContents.setVisualZoomLevelLimits(1, 3);
  win.setMenuBarVisibility(false);

  return pluto;
};

/**
 * Open a notebook that was requested from outside the app (a double-clicked
 * file, macOS "Open With", or a second launch) in a fresh window. Waits for the
 * Pluto server to be ready first.
 */
const openExternalNotebook = async (filePath: string): Promise<void> => {
  await Globals.whenStarted();
  // Pass null so the window stays blank until open() navigates it to the
  // notebook, rather than briefly flashing the welcome page.
  const pluto = createPlutoWindow(null);
  await pluto.open('path', filePath);
};

/** Bring an existing window to the front, or create one if none are open. */
const focusAnyWindow = (): void => {
  const [existing] = BrowserWindow.getAllWindows();
  if (existing) {
    if (existing.isMinimized()) existing.restore();
    existing.focus();
  } else {
    createPlutoWindow();
  }
};

// This method will be called when Electron has finished
// initialization and is ready to create browser windows.
// Some APIs can only be used after this event occurs.
app.whenReady().then(async () => {
  // If we were launched to open a notebook (e.g. double-clicked .jl on Windows,
  // where the path arrives in argv), route the first window straight to it.
  const notebookArg = firstNotebookPath(process.argv);

  // Show the loading window right away: initGlobals can take a while on first
  // run (it copies the bundled Julia depot to a writable location).
  const pluto = createPlutoWindow();
  if (notebookArg) pluto.pendingNotebookPath = notebookArg;
  await initGlobals();
  startup(app, MAIN_WINDOW_WEBPACK_ENTRY);

  // This is set here because it required the app to be ready
  session.defaultSession.on('will-download', (_event, item) => {
    const fileName = item.getFilename();
    const ext = path.extname(fileName).slice(1);
    const fileType =
      ext === 'html'
        ? 'HTML file'
        : ext === 'jl'
          ? 'Pluto Notebook'
          : 'Pluto Statefile';

    item.setSaveDialogOptions({
      message: 'Select location to export file',
      filters: [{ extensions: [ext], name: fileType }],
    });
  });

  createRequestListener();
});

// Quit when all windows are closed, except on macOS. There, it's common
// for applications and their menu bar to stay active until the user quits
// explicitly with Cmd + Q.
app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') {
    app.quit();
  }
});

app.on('activate', async () => {
  // 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 (BrowserWindow.getAllWindows().length === 0) {
    createPlutoWindow();
  }
});

// Kill the Julia/Pluto server process when the app quits.
app.on('will-quit', () => {
  Pluto.close();
});

app.on('open-file', (event, file) => {
  // macOS "Open With" / dock drop. (Windows delivers the path via argv instead:
  // see firstNotebookPath usage above.)
  event.preventDefault();
  if (isExtMatch(file)) {
    void openExternalNotebook(file);
  } else {
    generalLogger.info('open-file event: unsupported file type:', file);
  }
});

// This handles custom Pluto.jl routes by intercepting web requests
function createRequestListener() {
  session.defaultSession.webRequest.onBeforeRequest(async (details, next) => {
    const cancel = false;

    if (!details.webContentsId) {
      generalLogger.warn('Web request was made without defined webContentsId');
      next({ cancel });
      return;
    }

    const plutoWindow =
      GlobalWindowManager.getInstance().getWindowByWebContentsId(
        details.webContentsId,
      );

    if (!plutoWindow) {
      next({ cancel });
      return;
    }

    // In development, our path usually looks like /.../Pluto.jl/frontend
    // In production, our path usually looks like  /.../Pluto/KkVLI/frontend
    if (details.url.match(/\/Pluto(\.jl)?\/(.*\/)?frontend(-dist)?/g)) {
      const url = new URL(details.url);
      const tail = url.pathname.split('/').reverse()[0];

      generalLogger.verbose(
        'Triggered Pluto.jl server-side route detection!',
        details.url,
      );

      if (url.pathname.endsWith('/')) {
        next({ redirectURL: Pluto.resolveHtmlPath('index.html') });
        return;
      }
      if (tail === 'new') {
        // this should be synchronous so the user sees the Pluto.jl loading screen on index.html
        await plutoWindow.open('new');
        next({
          cancel: true,
        });
        return;
      }
      if (tail === 'open') {
        await plutoWindow.open('path', url.searchParams.get('path'));
        next({
          cancel: true,
        });
        return;
      }
      if (tail === 'edit') {
        next({
          redirectURL:
            Pluto.resolveHtmlPath('editor.html') + url.search.replace('?', '&'),
        });
        return;
      }
      // this route gets called when pasting a notebook into the welcome page
      if (tail === 'notebookupload') {
        next({
          redirectURL: new URL(
            `notebookupload?secret=${Globals.PLUTO_SECRET}`,
            Globals.PLUTO_URL,
          ).toString(),
        });
        return;
      }
      // The pluto.land upload flow (and any renderer-side `fetch` of the HTML
      // export) hits this relative URL, which resolves against the file:// editor
      // page and would otherwise 404. Redirect it to the real Pluto server,
      // preserving `id`/`offline_bundle` and adding the secret for auth.
      if (tail === 'notebookexport') {
        next({
          redirectURL: withSearchParams(`notebookexport${url.search}`, {
            secret: Globals.PLUTO_SECRET,
          }).toString(),
        });
        return;
      }
    }

    next({ cancel });
  });

  // The editor loads from a file:// page (origin "null"), but export and other
  // authenticated requests target the http://localhost Pluto server. So we need `Access-Control-Allow-Origin: *`. Since this is our own local server inside our own app, inject
  // the header.
  session.defaultSession.webRequest.onHeadersReceived((details, callback) => {
    if (Globals.PLUTO_STARTED && details.url.startsWith(Globals.PLUTO_URL.origin)) {
      const responseHeaders = { ...details.responseHeaders };
      for (const key of Object.keys(responseHeaders)) {
        if (key.toLowerCase() === 'access-control-allow-origin') {
          delete responseHeaders[key];
        }
      }
      responseHeaders['Access-Control-Allow-Origin'] = ['*'];
      callback({ responseHeaders });
      return;
    }
    callback({});
  });

  // The pluto.land upload/delete requests are sent from the file:// editor, so
  // the browser attaches `Origin: null`, which pluto.land's endpoint rejects
  // ("Origin not allowed") even though it returns `Access-Control-Allow-Origin: *`.
  // pluto.land allows its own origin, so present that instead. (The response is
  // still `ACAO: *`, which satisfies the renderer's null-origin CORS check.)
  session.defaultSession.webRequest.onBeforeSendHeaders(
    { urls: ['https://pluto.land/*'] },
    (details, callback) => {
      const requestHeaders = { ...details.requestHeaders };
      for (const key of Object.keys(requestHeaders)) {
        if (key.toLowerCase() === 'origin') {
          delete requestHeaders[key];
        }
      }
      requestHeaders.Origin = 'https://pluto.land';
      callback({ requestHeaders });
    },
  );
}