feat: Load and switch services

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

14 files changed, 933 insertions, 279 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);
   });
diff --git a/packages/main/src/infrastructure/config/ReadConfigResult.ts b/packages/main/src/infrastructure/config/ReadConfigResult.ts
deleted file mode 100644
index 3b3ee55..0000000
--- a/packages/main/src/infrastructure/config/ReadConfigResult.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
- *
- * This file is part of Sophie.
- *
- * Sophie is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- * SPDX-License-Identifier: AGPL-3.0-only
- */
-
-type ReadConfigResult = { found: true; data: unknown } | { found: false };
-
-export default ReadConfigResult;
diff --git a/packages/main/src/infrastructure/electron/RendererBridge.ts b/packages/main/src/infrastructure/electron/RendererBridge.ts
new file mode 100644
index 0000000..8633b9d
--- /dev/null
+++ b/packages/main/src/infrastructure/electron/RendererBridge.ts
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
+ *
+ * This file is part of Sophie.
+ *
+ * Sophie is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import type { SharedStoreSnapshotOut } from '@sophie/shared';
+import {
+  addMiddleware,
+  getSnapshot,
+  IJsonPatch,
+  IMiddlewareEvent,
+  onPatch,
+} from 'mobx-state-tree';
+
+import type MainStore from '../../stores/MainStore';
+import Disposer from '../../utils/Disposer';
+import { getLogger } from '../../utils/log';
+
+const log = getLogger('RendererBridge');
+
+export type PatchListener = (patch: IJsonPatch[]) => void;
+
+export default class RendererBridge {
+  snapshot: SharedStoreSnapshotOut;
+
+  private readonly disposeOnPatch: Disposer;
+
+  private readonly disposeMiddleware: Disposer;
+
+  constructor(store: MainStore, listener: PatchListener) {
+    this.snapshot = getSnapshot(store.shared);
+
+    // The call for the currently pending action, if any.
+    let topLevelCall: IMiddlewareEvent | undefined;
+    // An array of accumulated patches if we're in an action, `undefined` otherwise.
+    let patches: IJsonPatch[] | undefined;
+
+    this.disposeOnPatch = onPatch(store.shared, (patch) => {
+      if (patches === undefined) {
+        // Update unprotected stores (outside an action) right away.
+        listener([patch]);
+      } else {
+        patches.push(patch);
+      }
+    });
+
+    this.disposeMiddleware = addMiddleware(store, (call, next, abort) => {
+      if (call.parentActionEvent !== undefined) {
+        // We're already in an action, there's no need to enter one.
+        next(call);
+        return;
+      }
+      if (patches !== undefined) {
+        log.error(
+          'Unexpected call',
+          call,
+          'during dispatching another call',
+          topLevelCall,
+          'with accumulated patches',
+          patches,
+        );
+        abort(undefined);
+        return;
+      }
+      // Make shure that the saved snapshot is consistent with the patches we're going to send.
+      this.snapshot = getSnapshot(store.shared);
+      topLevelCall = call;
+      patches = [];
+      try {
+        next(call);
+      } finally {
+        try {
+          if (patches.length > 0) {
+            listener(patches);
+          }
+        } finally {
+          topLevelCall = undefined;
+          patches = undefined;
+        }
+      }
+    });
+  }
+
+  dispose(): void {
+    this.disposeMiddleware();
+    this.disposeOnPatch();
+  }
+}
diff --git a/packages/main/src/infrastructure/electron/UserAgents.ts b/packages/main/src/infrastructure/electron/UserAgents.ts
new file mode 100644
index 0000000..af7f049
--- /dev/null
+++ b/packages/main/src/infrastructure/electron/UserAgents.ts
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
+ *
+ * This file is part of Sophie.
+ *
+ * Sophie is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+const CHROMELESS_USER_AGENT_REGEX = /^[^:]+:\/\/accounts\.google\.[^./]+\//;
+
+export default class UserAgents {
+  private readonly default: string;
+
+  private readonly chromeless: string;
+
+  constructor(readonly mainWindowUserAgent: string) {
+    this.default = mainWindowUserAgent.replaceAll(
+      /\s(sophie|Electron)\/\S+/g,
+      '',
+    );
+    this.chromeless = this.default.replace(/ Chrome\/\S+/, '');
+  }
+
+  serviceUserAgent(url?: string | undefined): string {
+    return url !== undefined && CHROMELESS_USER_AGENT_REGEX.test(url)
+      ? this.chromeless
+      : this.default;
+  }
+
+  fallbackUserAgent(devMode: boolean): string {
+    // Removing the electron version breaks redux devtools, so we only do this in production.
+    return devMode ? this.mainWindowUserAgent : this.default;
+  }
+}
diff --git a/packages/main/src/infrastructure/electron/impl/ElectronMainWindow.ts b/packages/main/src/infrastructure/electron/impl/ElectronMainWindow.ts
new file mode 100644
index 0000000..cff7957
--- /dev/null
+++ b/packages/main/src/infrastructure/electron/impl/ElectronMainWindow.ts
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
+ *
+ * This file is part of Sophie.
+ *
+ * Sophie is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import {
+  Action,
+  MainToRendererIpcMessage,
+  RendererToMainIpcMessage,
+} from '@sophie/shared';
+import { BrowserWindow, ipcMain, IpcMainEvent } from 'electron';
+import type { IJsonPatch } from 'mobx-state-tree';
+
+import type MainStore from '../../../stores/MainStore';
+import { getLogger } from '../../../utils/log';
+import RendererBridge from '../RendererBridge';
+import type { MainWindow, ServiceView } from '../types';
+
+import ElectronServiceView from './ElectronServiceView';
+import type ElectronViewFactory from './ElectronViewFactory';
+import { openDevToolsWhenReady } from './devTools';
+import lockWebContentsToFile from './lockWebContentsToFile';
+
+const log = getLogger('ElectronMainWindow');
+
+export default class ElectronMainWindow implements MainWindow {
+  private readonly browserWindow: BrowserWindow;
+
+  private readonly bridge: RendererBridge;
+
+  private readonly dispatchActionHandler = (
+    event: IpcMainEvent,
+    rawAction: unknown,
+  ): void => {
+    const { id } = event.sender;
+    if (id !== this.browserWindow.webContents.id) {
+      log.warn(
+        'Unexpected',
+        RendererToMainIpcMessage.DispatchAction,
+        'from webContents',
+        id,
+      );
+      return;
+    }
+    try {
+      const action = Action.parse(rawAction);
+      this.store.dispatch(action);
+    } catch (error) {
+      log.error('Error while dispatching renderer action', rawAction, error);
+    }
+  };
+
+  constructor(
+    private readonly store: MainStore,
+    private readonly parent: ElectronViewFactory,
+  ) {
+    this.browserWindow = new BrowserWindow({
+      show: false,
+      autoHideMenuBar: true,
+      darkTheme: store.shared.shouldUseDarkColors,
+      webPreferences: {
+        sandbox: true,
+        devTools: parent.devMode,
+        preload: parent.resources.getPath('preload', 'index.cjs'),
+      },
+    });
+
+    const { webContents } = this.browserWindow;
+
+    ipcMain.handle(RendererToMainIpcMessage.GetSharedStoreSnapshot, (event) => {
+      const { id } = event.sender;
+      if (id !== webContents.id) {
+        log.warn(
+          'Unexpected',
+          RendererToMainIpcMessage.GetSharedStoreSnapshot,
+          'from webContents',
+          id,
+        );
+        throw new Error('Invalid IPC call');
+      }
+      return this.bridge.snapshot;
+    });
+
+    this.bridge = new RendererBridge(store, (patch) => {
+      webContents.send(MainToRendererIpcMessage.SharedStorePatch, patch);
+    });
+
+    ipcMain.on(
+      RendererToMainIpcMessage.DispatchAction,
+      this.dispatchActionHandler,
+    );
+
+    webContents.userAgent = parent.userAgents.mainWindowUserAgent;
+
+    this.browserWindow.on('ready-to-show', () => this.browserWindow.show());
+
+    this.browserWindow.on('close', () => this.dispose());
+
+    if (parent.devMode) {
+      openDevToolsWhenReady(this.browserWindow);
+    }
+  }
+
+  bringToForeground(): void {
+    if (!this.browserWindow.isVisible()) {
+      this.browserWindow.show();
+    }
+    if (this.browserWindow.isMinimized()) {
+      this.browserWindow.restore();
+    }
+    this.browserWindow.focus();
+  }
+
+  setServiceView(serviceView: ServiceView | undefined) {
+    if (serviceView === undefined) {
+      // eslint-disable-next-line unicorn/no-null -- Electron API requires passing `null`.
+      this.browserWindow.setBrowserView(null);
+      return;
+    }
+    if (serviceView instanceof ElectronServiceView) {
+      this.browserWindow.setBrowserView(serviceView.browserView);
+      serviceView.browserView.setBackgroundColor('#fff');
+      return;
+    }
+    throw new TypeError(
+      'Unexpected ServiceView with no underlying BrowserView',
+    );
+  }
+
+  dispose() {
+    this.bridge.dispose();
+    this.browserWindow.destroy();
+    ipcMain.removeHandler(RendererToMainIpcMessage.GetSharedStoreSnapshot);
+    ipcMain.removeListener(
+      RendererToMainIpcMessage.DispatchAction,
+      this.dispatchActionHandler,
+    );
+  }
+
+  loadInterface(): Promise<void> {
+    return lockWebContentsToFile(
+      this.parent.resources,
+      'index.html',
+      this.browserWindow.webContents,
+    );
+  }
+
+  sendSharedStorePatch(patch: IJsonPatch[]): void {
+    this.browserWindow.webContents.send(
+      MainToRendererIpcMessage.SharedStorePatch,
+      patch,
+    );
+  }
+}
diff --git a/packages/main/src/infrastructure/electron/impl/ElectronPartition.ts b/packages/main/src/infrastructure/electron/impl/ElectronPartition.ts
new file mode 100644
index 0000000..e60ce21
--- /dev/null
+++ b/packages/main/src/infrastructure/electron/impl/ElectronPartition.ts
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
+ *
+ * This file is part of Sophie.
+ *
+ * Sophie is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import { Session, session } from 'electron';
+
+import type Profile from '../../../stores/Profile';
+import type { Partition } from '../types';
+
+import type ElectronViewFactory from './ElectronViewFactory';
+
+export default class ElectronPartition implements Partition {
+  readonly id: string;
+
+  readonly session: Session;
+
+  constructor(profile: Profile, parent: ElectronViewFactory) {
+    this.id = profile.id;
+    this.session = session.fromPartition(`persist:${profile.id}`);
+    this.session.setPermissionRequestHandler(
+      (_webContents, permission, callback) => {
+        // TODO Handle screen sharing.
+        callback(permission === 'notifications');
+      },
+    );
+    this.session.setUserAgent(parent.userAgents.serviceUserAgent());
+    this.session.webRequest.onBeforeSendHeaders(
+      ({ url, requestHeaders }, callback) => {
+        callback({
+          requestHeaders: {
+            ...requestHeaders,
+            'User-Agent': parent.userAgents.serviceUserAgent(url),
+          },
+        });
+      },
+    );
+  }
+
+  // eslint-disable-next-line class-methods-use-this -- Implementing interface method.
+  dispose(): void {
+    // No reactions to dispose yet.
+  }
+}
diff --git a/packages/main/src/infrastructure/electron/impl/ElectronServiceView.ts b/packages/main/src/infrastructure/electron/impl/ElectronServiceView.ts
new file mode 100644
index 0000000..c4f7e4d
--- /dev/null
+++ b/packages/main/src/infrastructure/electron/impl/ElectronServiceView.ts
@@ -0,0 +1,121 @@
+/*
+ * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
+ *
+ * This file is part of Sophie.
+ *
+ * Sophie is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import type { BrowserViewBounds } from '@sophie/shared';
+import { BrowserView } from 'electron';
+
+import type Service from '../../../stores/Service';
+import type Resources from '../../resources/Resources';
+import type { ServiceView } from '../types';
+
+import ElectronPartition from './ElectronPartition';
+import type ElectronViewFactory from './ElectronViewFactory';
+
+export default class ElectronServiceView implements ServiceView {
+  readonly id: string;
+
+  readonly partitionId: string;
+
+  readonly browserView: BrowserView;
+
+  constructor(
+    service: Service,
+    resources: Resources,
+    partition: ElectronPartition,
+    private readonly parent: ElectronViewFactory,
+  ) {
+    this.id = service.id;
+    this.partitionId = partition.id;
+    this.browserView = new BrowserView({
+      webPreferences: {
+        sandbox: true,
+        nodeIntegrationInSubFrames: true,
+        preload: resources.getPath('service-preload', 'index.cjs'),
+        session: partition.session,
+      },
+    });
+
+    const { webContents } = this.browserView;
+
+    function setLocation(url: string) {
+      service.setLocation({
+        url,
+        canGoBack: webContents.canGoBack(),
+        canGoForward: webContents.canGoForward(),
+      });
+    }
+
+    webContents.on('did-navigate', (_event, url) => {
+      setLocation(url);
+    });
+
+    webContents.on('did-navigate-in-page', (_event, url, isMainFrame) => {
+      if (isMainFrame) {
+        setLocation(url);
+      }
+    });
+
+    webContents.on('page-title-updated', (_event, title) => {
+      service.setTitle(title);
+    });
+
+    webContents.on('did-start-loading', () => {
+      service.startedLoading();
+    });
+
+    webContents.on('did-finish-load', () => {
+      service.finishedLoading();
+    });
+
+    webContents.on('render-process-gone', () => {
+      service.crashed();
+    });
+  }
+
+  get webContentsId(): number {
+    return this.browserView.webContents.id;
+  }
+
+  loadURL(url: string): Promise<void> {
+    return this.browserView.webContents.loadURL(url);
+  }
+
+  goBack(): void {
+    this.browserView.webContents.goBack();
+  }
+
+  goForward(): void {
+    this.browserView.webContents.goForward();
+  }
+
+  setBounds(bounds: BrowserViewBounds): void {
+    this.browserView.setBounds(bounds);
+  }
+
+  dispose(): void {
+    this.parent.unregisterServiceView(this.webContentsId);
+    setImmediate(() => {
+      // Undocumented electron API, see e.g., https://github.com/electron/electron/issues/29626
+      (
+        this.browserView.webContents as unknown as { destroy(): void }
+      ).destroy();
+    });
+  }
+}
diff --git a/packages/main/src/infrastructure/electron/impl/ElectronViewFactory.ts b/packages/main/src/infrastructure/electron/impl/ElectronViewFactory.ts
new file mode 100644
index 0000000..f8b4a36
--- /dev/null
+++ b/packages/main/src/infrastructure/electron/impl/ElectronViewFactory.ts
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
+ *
+ * This file is part of Sophie.
+ *
+ * Sophie is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import { readFile } from 'node:fs/promises';
+
+import { ServiceToMainIpcMessage } from '@sophie/service-shared';
+import { ipcMain, WebSource } from 'electron';
+
+import type MainStore from '../../../stores/MainStore';
+import type Profile from '../../../stores/Profile';
+import type Service from '../../../stores/Service';
+import { getLogger } from '../../../utils/log';
+import type Resources from '../../resources/Resources';
+import type UserAgents from '../UserAgents';
+import type { MainWindow, Partition, ServiceView, ViewFactory } from '../types';
+
+import ElectronMainWindow from './ElectronMainWindow';
+import ElectronPartition from './ElectronPartition';
+import ElectronServiceView from './ElectronServiceView';
+
+const log = getLogger('ElectronViewFactory');
+
+export default class ElectronViewFactory implements ViewFactory {
+  private readonly webContentsIdToServiceView = new Map<
+    number,
+    ElectronServiceView
+  >();
+
+  private serviceInjectSource: WebSource | undefined;
+
+  constructor(
+    readonly userAgents: UserAgents,
+    readonly resources: Resources,
+    readonly devMode: boolean,
+  ) {
+    ipcMain.handle(ServiceToMainIpcMessage.ApiExposedInMainWorld, (event) => {
+      if (!this.webContentsIdToServiceView.has(event.sender.id)) {
+        log.error(
+          'Unexpected',
+          ServiceToMainIpcMessage.ApiExposedInMainWorld,
+          'IPC message from webContents',
+          event.sender.id,
+        );
+        throw new Error('Invalid IPC call');
+      }
+      if (this.serviceInjectSource === undefined) {
+        log.error('Service inject source was not loaded');
+      }
+      return this.serviceInjectSource;
+    });
+  }
+
+  async createMainWindow(store: MainStore): Promise<MainWindow> {
+    const mainWindow = new ElectronMainWindow(store, this);
+    await mainWindow.loadInterface();
+    return mainWindow;
+  }
+
+  createPartition(profile: Profile): Partition {
+    return new ElectronPartition(profile, this);
+  }
+
+  createServiceView(service: Service, partition: Partition): ServiceView {
+    if (partition instanceof ElectronPartition) {
+      const serviceView = new ElectronServiceView(
+        service,
+        this.resources,
+        partition,
+        this,
+      );
+      this.webContentsIdToServiceView.set(
+        serviceView.webContentsId,
+        serviceView,
+      );
+      return serviceView;
+    }
+    throw new TypeError('Unexpected ProfileSession is not a WrappedSession');
+  }
+
+  async loadServiceInject(): Promise<void> {
+    const injectPackage = 'service-inject';
+    const injectFile = 'index.js';
+    const injectPath = this.resources.getPath(injectPackage, injectFile);
+    this.serviceInjectSource = {
+      code: await readFile(injectPath, 'utf-8'),
+      url: this.resources.getFileURL(injectPackage, injectFile),
+    };
+  }
+
+  dispose(): void {
+    if (this.webContentsIdToServiceView.size > 0) {
+      throw new Error(
+        'Must dispose all ServiceView instances before disposing ViewFactory',
+      );
+    }
+    ipcMain.removeHandler(ServiceToMainIpcMessage.ApiExposedInMainWorld);
+  }
+
+  unregisterServiceView(id: number): void {
+    this.webContentsIdToServiceView.delete(id);
+  }
+}
diff --git a/packages/main/src/infrastructure/electron/types.ts b/packages/main/src/infrastructure/electron/types.ts
new file mode 100644
index 0000000..9f03214
--- /dev/null
+++ b/packages/main/src/infrastructure/electron/types.ts
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
+ *
+ * This file is part of Sophie.
+ *
+ * Sophie is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import type { BrowserViewBounds } from '@sophie/shared';
+
+import type MainStore from '../../stores/MainStore';
+import type Profile from '../../stores/Profile';
+import type Service from '../../stores/Service';
+
+export interface ViewFactory {
+  createMainWindow(store: MainStore): Promise<MainWindow>;
+
+  createPartition(profile: Profile): Partition;
+
+  createServiceView(service: Service, partition: Partition): ServiceView;
+
+  loadServiceInject(): Promise<void>;
+
+  dispose(): void;
+}
+
+export interface MainWindow {
+  bringToForeground(): void;
+
+  setServiceView(serviceView: ServiceView | undefined): void;
+
+  dispose(): void;
+}
+
+export interface Partition {
+  readonly id: string;
+
+  dispose(): void;
+}
+
+export interface ServiceView {
+  readonly id: string;
+
+  readonly partitionId: string;
+
+  loadURL(url: string): Promise<void>;
+
+  goBack(): void;
+
+  goForward(): void;
+
+  setBounds(bounds: BrowserViewBounds): void;
+
+  dispose(): void;
+}
diff --git a/packages/main/src/initReactions.ts b/packages/main/src/initReactions.ts
index a87b323..b6a8502 100644
--- a/packages/main/src/initReactions.ts
+++ b/packages/main/src/initReactions.ts
@@ -18,9 +18,15 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import { app } from 'electron';
+import { app, session } from 'electron';
 
 import ConfigFile from './infrastructure/config/impl/ConfigFile';
+import UserAgents from './infrastructure/electron/UserAgents';
+import ElectronViewFactory from './infrastructure/electron/impl/ElectronViewFactory';
+import { installDevToolsExtensions } from './infrastructure/electron/impl/devTools';
+import hardenSession from './infrastructure/electron/impl/hardenSession';
+import getDistResources from './infrastructure/resources/impl/getDistResources';
+import loadServices from './reactions/loadServices';
 import synchronizeConfig from './reactions/synchronizeConfig';
 import synchronizeNativeTheme from './reactions/synchronizeNativeTheme';
 import type MainStore from './stores/MainStore';
@@ -28,6 +34,7 @@ import type Disposer from './utils/Disposer';
 
 export default async function initReactions(
   store: MainStore,
+  devMode: boolean,
 ): Promise<Disposer> {
   const configRepository = new ConfigFile(app.getPath('userData'));
   const disposeConfigController = await synchronizeConfig(
@@ -36,7 +43,20 @@ export default async function initReactions(
   );
   await app.whenReady();
   const disposeNativeThemeController = synchronizeNativeTheme(store.shared);
-
+  const resources = getDistResources(devMode);
+  hardenSession(resources, devMode, session.defaultSession);
+  if (devMode) {
+    await installDevToolsExtensions();
+  }
+  const userAgents = new UserAgents(app.userAgentFallback);
+  app.userAgentFallback = userAgents.fallbackUserAgent(devMode);
+  const viewFactory = new ElectronViewFactory(userAgents, resources, devMode);
+  const [mainWindow] = await Promise.all([
+    viewFactory.createMainWindow(store),
+    viewFactory.loadServiceInject(),
+  ]);
+  store.setMainWindow(mainWindow);
+  loadServices(store, viewFactory);
   return () => {
     disposeNativeThemeController();
     disposeConfigController();
diff --git a/packages/main/src/reactions/loadServices.ts b/packages/main/src/reactions/loadServices.ts
new file mode 100644
index 0000000..533ef95
--- /dev/null
+++ b/packages/main/src/reactions/loadServices.ts
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
+ *
+ * This file is part of Sophie.
+ *
+ * Sophie is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import { autorun, reaction } from 'mobx';
+import { addDisposer } from 'mobx-state-tree';
+
+import type {
+  MainWindow,
+  Partition,
+  ServiceView,
+  ViewFactory,
+} from '../infrastructure/electron/types';
+import type MainStore from '../stores/MainStore';
+import type Service from '../stores/Service';
+import { getLogger } from '../utils/log';
+
+const log = getLogger('loadServices');
+
+export default function loadServices(
+  store: MainStore,
+  viewFactory: ViewFactory,
+): void {
+  const profilesToPartitions = new Map<string, Partition>();
+  const servicesToViews = new Map<string, ServiceView>();
+
+  type ReactionArgs = [
+    Map<string, Service>,
+    MainWindow | undefined,
+    Service | undefined,
+    unknown,
+  ];
+
+  const disposer = reaction(
+    (): ReactionArgs => [
+      new Map(store.shared.servicesById),
+      store.mainWindow,
+      store.visibleService,
+      [...store.shared.servicesById.values()].map((service) => [
+        service.settings.profile,
+        service.shouldBeLoaded,
+      ]),
+    ],
+    ([servicesById, mainWindow, visibleService]: ReactionArgs) => {
+      log.debug('Loading service partitions and views');
+
+      const partitionsToDispose = new Map(profilesToPartitions);
+      servicesById.forEach((service) => {
+        const {
+          settings: { profile },
+        } = service;
+        const { id: profileId } = profile;
+        partitionsToDispose.delete(profileId);
+        if (!profilesToPartitions.has(profileId)) {
+          log.debug('Creating partition for profile', profileId);
+          profilesToPartitions.set(
+            profileId,
+            viewFactory.createPartition(profile),
+          );
+        }
+      });
+
+      const viewsToDispose = new Map(servicesToViews);
+      servicesById.forEach((service, serviceId) => {
+        if (service.shouldBeLoaded) {
+          let view = servicesToViews.get(serviceId);
+          const {
+            settings: {
+              profile: { id: profileId },
+            },
+          } = service;
+          if (view === undefined || view.partitionId !== profileId) {
+            log.debug('Creating view for service', serviceId);
+            const partition = profilesToPartitions.get(profileId);
+            if (partition === undefined) {
+              throw new Error(`Missing Partition ${profileId}`);
+            }
+            view = viewFactory.createServiceView(service, partition);
+            view.setBounds(store.browserViewBounds);
+            servicesToViews.set(serviceId, view);
+            service.setServiceView(view);
+            const { urlToLoad } = service;
+            view.loadURL(urlToLoad).catch((error) => {
+              log.warn(
+                'Cannot URL',
+                urlToLoad,
+                'for service',
+                serviceId,
+                error,
+              );
+            });
+          } else {
+            viewsToDispose.delete(serviceId);
+          }
+        }
+      });
+
+      mainWindow?.setServiceView(visibleService?.serviceView);
+      log.debug('Visible service is', visibleService?.serviceView?.id);
+
+      viewsToDispose.forEach((view, serviceId) => {
+        const currentView = servicesToViews.get(serviceId);
+        if (currentView === view) {
+          servicesToViews.delete(serviceId);
+          const service = store.shared.servicesById.get(serviceId);
+          if (service !== undefined) {
+            service.setServiceView(undefined);
+          }
+          log.debug('Disposing view for service', serviceId);
+        } else {
+          log.debug('Changed partition for service', serviceId);
+        }
+        view.dispose();
+      });
+
+      partitionsToDispose.forEach((partition, profileId) => {
+        log.debug('Disposing partition for profile', profileId);
+        profilesToPartitions.delete(profileId);
+        partition.dispose();
+      });
+    },
+    {
+      fireImmediately: true,
+    },
+  );
+
+  const resizeDisposer = autorun(() => {
+    store.visibleService?.serviceView?.setBounds(store.browserViewBounds);
+  });
+
+  addDisposer(store, () => {
+    resizeDisposer();
+    disposer();
+    store.mainWindow?.setServiceView(undefined);
+    servicesToViews.forEach((serviceView, serviceId) => {
+      store.shared.servicesById.get(serviceId)?.setServiceView(undefined);
+      serviceView.dispose();
+    });
+    profilesToPartitions.forEach((partition) => partition.dispose());
+  });
+}
diff --git a/packages/main/src/stores/MainStore.ts b/packages/main/src/stores/MainStore.ts
index ff014c9..9ac56f4 100644
--- a/packages/main/src/stores/MainStore.ts
+++ b/packages/main/src/stores/MainStore.ts
@@ -18,14 +18,19 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import type { BrowserViewBounds } from '@sophie/shared';
+import type { Action, BrowserViewBounds } from '@sophie/shared';
 import { applySnapshot, Instance, types } from 'mobx-state-tree';
 
+import type { MainWindow } from '../infrastructure/electron/types';
+import { getLogger } from '../utils/log';
+
 import GlobalSettings from './GlobalSettings';
 import Profile from './Profile';
 import Service from './Service';
 import SharedStore from './SharedStore';
 
+const log = getLogger('MainStore');
+
 const MainStore = types
   .model('MainStore', {
     browserViewBounds: types.optional(
@@ -49,11 +54,49 @@ const MainStore = types
     get services(): Service[] {
       return self.shared.services;
     },
+    get visibleService(): Service | undefined {
+      const { selectedService } = this.settings;
+      return selectedService !== undefined && selectedService.shouldBeLoaded
+        ? selectedService
+        : undefined;
+    },
   }))
+  .volatile(
+    (): {
+      mainWindow: MainWindow | undefined;
+    } => ({
+      mainWindow: undefined,
+    }),
+  )
   .actions((self) => ({
     setBrowserViewBounds(bounds: BrowserViewBounds): void {
       applySnapshot(self.browserViewBounds, bounds);
     },
+    dispatch(action: Action): void {
+      switch (action.action) {
+        case 'reload-all-services':
+          // TODO
+          break;
+        case 'set-browser-view-bounds':
+          this.setBrowserViewBounds(action.browserViewBounds);
+          break;
+        case 'set-selected-service-id':
+          self.settings.setSelectedServiceId(action.serviceId);
+          break;
+        case 'set-theme-source':
+          self.settings.setThemeSource(action.themeSource);
+          break;
+        default:
+          log.error('Unknown action to dispatch', action);
+          break;
+      }
+    },
+    setMainWindow(mainWindow: MainWindow | undefined): void {
+      self.mainWindow = mainWindow;
+    },
+    beforeDestroy(): void {
+      self.mainWindow?.dispose();
+    },
   }));
 
 /*
diff --git a/packages/main/src/stores/Service.ts b/packages/main/src/stores/Service.ts
index fea0bdf..5302dd4 100644
--- a/packages/main/src/stores/Service.ts
+++ b/packages/main/src/stores/Service.ts
@@ -22,6 +22,7 @@ import type { UnreadCount } from '@sophie/service-shared';
 import { Service as ServiceBase } from '@sophie/shared';
 import { Instance, getSnapshot } from 'mobx-state-tree';
 
+import type { ServiceView } from '../infrastructure/electron/types';
 import overrideProps from '../utils/overrideProps';
 
 import ServiceSettings from './ServiceSettings';
@@ -35,7 +36,20 @@ const Service = overrideProps(ServiceBase, {
       const { id, settings } = self;
       return { ...getSnapshot(settings), id };
     },
+    get urlToLoad(): string {
+      return self.currentUrl ?? self.settings.url;
+    },
+    get shouldBeLoaded(): boolean {
+      return self.state !== 'crashed';
+    },
   }))
+  .volatile(
+    (): {
+      serviceView: ServiceView | undefined;
+    } => ({
+      serviceView: undefined,
+    }),
+  )
   .actions((self) => ({
     setLocation({
       url,
@@ -73,6 +87,9 @@ const Service = overrideProps(ServiceBase, {
         self.indirectMessageCount = indirect;
       }
     },
+    setServiceView(serviceView: ServiceView | undefined): void {
+      self.serviceView = serviceView;
+    },
   }));
 
 /*
diff --git a/packages/service-preload/src/index.ts b/packages/service-preload/src/index.ts
index 5383f42..e546f2f 100644
--- a/packages/service-preload/src/index.ts
+++ b/packages/service-preload/src/index.ts
@@ -24,7 +24,7 @@ import { ipcRenderer, webFrame } from 'electron';
 if (webFrame.parent === null) {
   // Inject CSS to simulate `browserView.setBackgroundColor`.
   // This is injected before the page loads, so the styles from the website will overwrite it.
-  webFrame.insertCSS('html { background-color: #fff; }');
+  webFrame.insertCSS(':root { background-color: #fff; }');
 }
 
 /**