feat: Load and switch services

Signed-off-by: Kristóf Marussy <kristof@marussy.com>

1 files changed, 8 insertions, 252 deletions

diff --git a/packages/main/src/index.ts b/packages/main/src/index.ts
index f5f6be4..40b15f0 100644
--- a/packages/main/src/index.ts
+++ b/packages/main/src/index.ts
@@ -19,34 +19,13 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import { readFileSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
 import { arch } from 'node:os';
 
-import {
-  ServiceToMainIpcMessage,
-  UnreadCount,
-  WebSource,
-} from '@sophie/service-shared';
-import {
-  Action,
-  MainToRendererIpcMessage,
-  RendererToMainIpcMessage,
-} from '@sophie/shared';
-import { app, BrowserView, BrowserWindow, ipcMain } from 'electron';
+import { app } from 'electron';
 import { ensureDirSync } from 'fs-extra';
-import { autorun } from 'mobx';
-import { getSnapshot, onAction, onPatch } from 'mobx-state-tree';
 import osName from 'os-name';
 
-import {
-  enableStacktraceSourceMaps,
-  installDevToolsExtensions,
-  openDevToolsWhenReady,
-} from './infrastructure/electron/impl/devTools';
-import hardenSession from './infrastructure/electron/impl/hardenSession';
-import lockWebContentsToFile from './infrastructure/electron/impl/lockWebContentsToFile';
-import getDistResources from './infrastructure/resources/impl/getDistResources';
+import { enableStacktraceSourceMaps } from './infrastructure/electron/impl/devTools';
 import initReactions from './initReactions';
 import { createMainStore } from './stores/MainStore';
 import { getLogger } from './utils/log';
@@ -81,15 +60,6 @@ app.commandLine.appendSwitch(
   'HardwareMediaKeyHandling,MediaSessionService',
 );
 
-// Remove sophie and electron from the user-agent string to avoid detection.
-const originalUserAgent = app.userAgentFallback;
-const userAgent = originalUserAgent.replaceAll(/\s(sophie|Electron)\/\S+/g, '');
-const chromelessUserAgent = userAgent.replace(/ Chrome\/\S+/, '');
-// Removing the electron version breaks redux devtools, so we only do this in production.
-if (!isDevelopment) {
-  app.userAgentFallback = userAgent;
-}
-
 app.setAboutPanelOptions({
   applicationVersion: [
     `Version: ${app.getVersion()}`,
@@ -107,215 +77,10 @@ app.setAboutPanelOptions({
   version: '',
 });
 
-const resources = getDistResources(isDevelopment);
-
-const serviceInjectPath = resources.getPath('service-inject', 'index.js');
-const serviceInject: WebSource = {
-  code: readFileSync(serviceInjectPath, 'utf8'),
-  url: resources.getFileURL('service-inject', 'index.js'),
-};
-
-let mainWindow: BrowserWindow | undefined;
-
 const store = createMainStore();
 
-initReactions(store)
-  // eslint-disable-next-line promise/always-return -- `then` instead of top-level await.
-  .then((disposeCompositionRoot) => {
-    app.on('will-quit', disposeCompositionRoot);
-  })
-  .catch((error) => {
-    log.log('Failed to initialize application', error);
-  });
-
-async function createWindow(): Promise<unknown> {
-  mainWindow = new BrowserWindow({
-    show: false,
-    autoHideMenuBar: true,
-    webPreferences: {
-      sandbox: true,
-      devTools: isDevelopment,
-      preload: resources.getPath('preload', 'index.cjs'),
-    },
-  });
-
-  const { webContents } = mainWindow;
-
-  webContents.userAgent = originalUserAgent;
-
-  hardenSession(resources, isDevelopment, webContents.session);
-
-  if (isDevelopment) {
-    openDevToolsWhenReady(mainWindow);
-  }
-
-  mainWindow.on('ready-to-show', () => {
-    mainWindow?.show();
-  });
-
-  const browserView = new BrowserView({
-    webPreferences: {
-      sandbox: true,
-      nodeIntegrationInSubFrames: true,
-      preload: resources.getPath('service-preload', 'index.cjs'),
-      partition: 'persist:service',
-    },
-  });
-
-  browserView.webContents.userAgent = userAgent;
-
-  autorun(() => {
-    browserView.setBounds(store.browserViewBounds);
-  });
-  mainWindow.setBrowserView(browserView);
-
-  ipcMain.handle(RendererToMainIpcMessage.GetSharedStoreSnapshot, (event) => {
-    if (event.sender.id !== webContents.id) {
-      log.warn(
-        'Unexpected',
-        RendererToMainIpcMessage.GetSharedStoreSnapshot,
-        'from webContents',
-        event.sender.id,
-      );
-      throw new Error('Invalid IPC call');
-    }
-    return getSnapshot(store.shared);
-  });
-
-  async function reloadServiceInject() {
-    try {
-      serviceInject.code = await readFile(serviceInjectPath, 'utf8');
-    } catch (error) {
-      log.error('Error while reloading', serviceInjectPath, error);
-    }
-    browserView.webContents.reload();
-  }
-
-  ipcMain.on(RendererToMainIpcMessage.DispatchAction, (event, rawAction) => {
-    if (event.sender.id !== webContents.id) {
-      log.warn(
-        'Unexpected',
-        RendererToMainIpcMessage.DispatchAction,
-        'from webContents',
-        event.sender.id,
-      );
-      return;
-    }
-    try {
-      const actionToDispatch = Action.parse(rawAction);
-      switch (actionToDispatch.action) {
-        case 'set-selected-service-id':
-          store.settings.setSelectedServiceId(actionToDispatch.serviceId);
-          break;
-        case 'set-browser-view-bounds':
-          store.setBrowserViewBounds(actionToDispatch.browserViewBounds);
-          break;
-        case 'set-theme-source':
-          store.settings.setThemeSource(actionToDispatch.themeSource);
-          break;
-        case 'reload-all-services':
-          reloadServiceInject().catch((error) => {
-            log.error('Failed to reload browserView', error);
-          });
-          break;
-        default:
-          log.error('Unexpected action from UI renderer:', actionToDispatch);
-          break;
-      }
-    } catch (error) {
-      log.error('Error while dispatching renderer action', rawAction, error);
-    }
-  });
-
-  const batchedPatches: unknown[] = [];
-  onPatch(store.shared, (patch) => {
-    batchedPatches.push(patch);
-  });
-  onAction(
-    store,
-    () => {
-      if (batchedPatches.length > 0) {
-        webContents.send(
-          MainToRendererIpcMessage.SharedStorePatch,
-          batchedPatches,
-        );
-        batchedPatches.splice(0);
-      }
-    },
-    true,
-  );
-
-  ipcMain.handle(ServiceToMainIpcMessage.ApiExposedInMainWorld, (event) => {
-    if (event.sender.id !== browserView.webContents.id) {
-      log.warn(
-        'Unexpected',
-        ServiceToMainIpcMessage.ApiExposedInMainWorld,
-        'from webContents',
-        event.sender.id,
-      );
-      throw new Error('Invalid IPC call');
-    }
-    return serviceInject;
-  });
-
-  browserView.webContents.on('ipc-message', (_event, channel, ...args) => {
-    try {
-      switch (channel) {
-        case ServiceToMainIpcMessage.ApiExposedInMainWorld:
-          // Asynchronous message with reply must be handled in `ipcMain.handle`,
-          // otherwise electron emits a no handler registered warning.
-          break;
-        case ServiceToMainIpcMessage.SetUnreadCount:
-          log.log('Unread count:', UnreadCount.parse(args[0]));
-          break;
-        default:
-          log.error('Unknown IPC message:', channel, args);
-          break;
-      }
-    } catch (error) {
-      log.error('Error while processing IPC message:', channel, args, error);
-    }
-  });
-
-  browserView.webContents.session.setPermissionRequestHandler(
-    (_webContents, _permission, callback) => {
-      callback(false);
-    },
-  );
-
-  browserView.webContents.session.webRequest.onBeforeSendHeaders(
-    ({ url, requestHeaders }, callback) => {
-      const requestUserAgent = /^[^:]+:\/\/accounts\.google\.[^./]+\//.test(url)
-        ? chromelessUserAgent
-        : userAgent;
-      callback({
-        requestHeaders: {
-          ...requestHeaders,
-          'User-Agent': requestUserAgent,
-        },
-      });
-    },
-  );
-
-  browserView.webContents
-    .loadURL('https://gitlab.com/say-hi-to-sophie/sophie')
-    .catch((error) => {
-      log.error('Failed to load browser', error);
-    });
-
-  return lockWebContentsToFile(resources, 'index.html', webContents);
-}
-
 app.on('second-instance', () => {
-  if (mainWindow !== undefined) {
-    if (!mainWindow.isVisible()) {
-      mainWindow.show();
-    }
-    if (mainWindow.isMinimized()) {
-      mainWindow.restore();
-    }
-    mainWindow.focus();
-  }
+  store.mainWindow?.bringToForeground();
 });
 
 app.on('window-all-closed', () => {
@@ -324,20 +89,11 @@ app.on('window-all-closed', () => {
   }
 });
 
-app
-  .whenReady()
-  .then(async () => {
-    if (isDevelopment) {
-      try {
-        await installDevToolsExtensions();
-      } catch (error) {
-        log.error('Failed to install devtools extensions', error);
-      }
-    }
-
-    return createWindow();
+initReactions(store, isDevelopment)
+  // eslint-disable-next-line promise/always-return -- `then` instead of top-level await.
+  .then((disposeCompositionRoot) => {
+    app.on('will-quit', disposeCompositionRoot);
   })
   .catch((error) => {
-    log.error('Failed to create window', error);
-    process.exit(1);
+    log.log('Failed to initialize application', error);
   });