feat: Load and switch services

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

8 files changed, 684 insertions, 23 deletions

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;
+}