Add better type safety around Channels (#6133)

* Add better type safety around Channels

- Reallow non-JSON serializable complex types

- Remove unnecessary JSON serialization step to IPC

- Remove unnecesary injectable-ization of MessageChannel and
  RequestChannel declarations

- Add channel listener injectable getter function to remove general need
  for type casting and improve type safety

Signed-off-by: Sebastian Malton <sebastian@malton.name>

* Add check to verify data in IPC related tests

Signed-off-by: Sebastian Malton <sebastian@malton.name>

* Fix implementation in light of new safety check in tests

Signed-off-by: Sebastian Malton <sebastian@malton.name>

* Fix listener ID clash potential

Signed-off-by: Sebastian Malton <sebastian@malton.name>

* Switch to not forcing split of request channel handlers being seperate from the listener decl

Signed-off-by: Sebastian Malton <sebastian@malton.name>

* Move message channels to changed signature too

Signed-off-by: Sebastian Malton <sebastian@malton.name>

* Fix not registering listener

Signed-off-by: Sebastian Malton <sebastian@malton.name>

* Fix test imports

Signed-off-by: Sebastian Malton <sebastian@malton.name>

* Fix type errors

Signed-off-by: Sebastian Malton <sebastian@malton.name>

* Refactor listening of different channel kinds

Signed-off-by: Sebastian Malton <sebastian@malton.name>

* Add test covering new checking code for request channel handlers

Signed-off-by: Sebastian Malton <sebastian@malton.name>

Signed-off-by: Sebastian Malton <sebastian@malton.name>

src/main/app-paths/app-paths-request-channel-listener.injectable.ts

@@ -2,26 +2,17 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable } from "@ogre-tools/injectable";
-import type { RequestChannelListener } from "../../common/utils/channel/request-channel-listener-injection-token";
-import { requestChannelListenerInjectionToken } from "../../common/utils/channel/request-channel-listener-injection-token";
-import type { AppPathsChannel } from "../../common/app-paths/app-paths-channel.injectable";
-import appPathsChannelInjectable from "../../common/app-paths/app-paths-channel.injectable";
+import { appPathsChannel } from "../../common/app-paths/app-paths-channel";
 import appPathsInjectable from "../../common/app-paths/app-paths.injectable";
+import { getRequestChannelListenerInjectable } from "../utils/channel/channel-listeners/listener-tokens";
 
-const appPathsRequestChannelListenerInjectable = getInjectable({
-  id: "app-paths-request-channel-listener",
-
-  instantiate: (di): RequestChannelListener<AppPathsChannel> => {
-    const channel = di.inject(appPathsChannelInjectable);
+const appPathsRequestChannelListenerInjectable = getRequestChannelListenerInjectable({
+  channel: appPathsChannel,
+  handler: (di) => {
     const appPaths = di.inject(appPathsInjectable);
 
-    return {
-      channel,
-      handler: () => appPaths,
-    };
+    return () => appPaths;
   },
-  injectionToken: requestChannelListenerInjectionToken,
 });
 
 export default appPathsRequestChannelListenerInjectable;

src/main/application-update/restart-and-install-update/restart-and-install-update-listener.injectable.ts

@@ -2,25 +2,14 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable } from "@ogre-tools/injectable";
-import restartAndInstallUpdateChannel from "../../../common/application-update/restart-and-install-update-channel/restart-and-install-update-channel.injectable";
-import { messageChannelListenerInjectionToken } from "../../../common/utils/channel/message-channel-listener-injection-token";
+import { restartAndInstallUpdateChannel } from "../../../common/application-update/restart-and-install-update-channel";
+import { getMessageChannelListenerInjectable } from "../../../common/utils/channel/message-channel-listener-injection-token";
 import quitAndInstallUpdateInjectable from "../quit-and-install-update.injectable";
 
-const restartAndInstallUpdateListenerInjectable = getInjectable({
-  id: "restart-and-install-update-listener",
-
-  instantiate: (di) => {
-    const quitAndInstall = di.inject(quitAndInstallUpdateInjectable);
-    const channel = di.inject(restartAndInstallUpdateChannel);
-
-    return {
-      channel,
-      handler: quitAndInstall,
-    };
-  },
-
-  injectionToken: messageChannelListenerInjectionToken,
+const restartAndInstallUpdateListenerInjectable = getMessageChannelListenerInjectable({
+  id: "restart",
+  channel: restartAndInstallUpdateChannel,
+  handler: (di) => di.inject(quitAndInstallUpdateInjectable),
 });
 
 export default restartAndInstallUpdateListenerInjectable;

src/main/application-update/watch-if-update-should-happen-on-quit/watch-if-update-should-happen-on-quit.injectable.ts

@@ -7,7 +7,7 @@ import { autorun } from "mobx";
 import { getStartableStoppable } from "../../../common/utils/get-startable-stoppable";
 import setUpdateOnQuitInjectable from "../../electron-app/features/set-update-on-quit.injectable";
 import selectedUpdateChannelInjectable from "../../../common/application-update/selected-update-channel/selected-update-channel.injectable";
-import type { UpdateChannel } from "../../../common/application-update/update-channels";
+import type { ReleaseChannel, UpdateChannel } from "../../../common/application-update/update-channels";
 import discoveredUpdateVersionInjectable from "../../../common/application-update/discovered-update-version/discovered-update-version.injectable";
 
 const watchIfUpdateShouldHappenOnQuitInjectable = getInjectable({
@@ -20,33 +20,26 @@ const watchIfUpdateShouldHappenOnQuitInjectable = getInjectable({
 
     return getStartableStoppable("watch-if-update-should-happen-on-quit", () =>
       autorun(() => {
-        const sufficientlyStableUpdateChannels =
-          getSufficientlyStableUpdateChannels(selectedUpdateChannel.value.get());
+        const sufficientlyStableUpdateChannels = getSufficientlyStableUpdateChannels(selectedUpdateChannel.value.get());
+        const updateIsDiscoveredFromChannel = discoveredVersionState.value.get()?.updateChannel;
 
-        const discoveredVersion = discoveredVersionState.value.get();
-
-        const updateIsDiscoveredFromChannel = discoveredVersion?.updateChannel;
-
-        const updateOnQuit = updateIsDiscoveredFromChannel
-          ? sufficientlyStableUpdateChannels.includes(
-            updateIsDiscoveredFromChannel,
-          )
-          : false;
-
-        setUpdateOnQuit(updateOnQuit);
+        setUpdateOnQuit((
+          updateIsDiscoveredFromChannel
+            ? sufficientlyStableUpdateChannels.includes(updateIsDiscoveredFromChannel.id)
+            : false
+        ));
       }),
     );
   },
 });
 
-const getSufficientlyStableUpdateChannels = (updateChannel: UpdateChannel): UpdateChannel[] => {
+const getSufficientlyStableUpdateChannels = (updateChannel: UpdateChannel): ReleaseChannel[] => {
   if (!updateChannel.moreStableUpdateChannel) {
-    return [updateChannel];
+    return [updateChannel.id];
   }
 
   return [
-    updateChannel,
-
+    updateChannel.id,
     ...getSufficientlyStableUpdateChannels(updateChannel.moreStableUpdateChannel),
   ];
 };

src/main/build-version/setup-channel.injectable.ts

@@ -2,22 +2,17 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable } from "@ogre-tools/injectable";
-import { requestChannelListenerInjectionToken } from "../../common/utils/channel/request-channel-listener-injection-token";
 import { buildVersionChannel } from "../../common/vars/build-semantic-version.injectable";
+import { getRequestChannelListenerInjectable } from "../utils/channel/channel-listeners/listener-tokens";
 import buildVersionInjectable from "../vars/build-version/build-version.injectable";
 
-const setupBuildVersionRequestChannelInjectable = getInjectable({
-  id: "setup-build-version-request-channel",
-  instantiate: (di) => {
+const buildVersionChannelListenerInjectable = getRequestChannelListenerInjectable({
+  channel: buildVersionChannel,
+  handler: (di) => {
     const buildVersion = di.inject(buildVersionInjectable);
 
-    return {
-      channel: buildVersionChannel,
-      handler: () => buildVersion.get(),
-    };
+    return () => buildVersion.get();
   },
-  injectionToken: requestChannelListenerInjectionToken,
 });
 
-export default setupBuildVersionRequestChannelInjectable;
+export default buildVersionChannelListenerInjectable;

src/main/helm/exec-helm/exec-helm.injectable.ts

@@ -6,9 +6,8 @@ import { getInjectable } from "@ogre-tools/injectable";
 import execFileInjectable from "../../../common/fs/exec-file.injectable";
 import helmBinaryPathInjectable from "../helm-binary-path.injectable";
 import type { AsyncResult } from "../../../common/utils/async-result";
-import { getErrorMessage } from "../../../common/utils/get-error-message";
 
-export type ExecHelm = (args: string[]) => Promise<AsyncResult<string>>;
+export type ExecHelm = (args: string[]) => Promise<AsyncResult<string, string>>;
 
 const execHelmInjectable = getInjectable({
   id: "exec-helm",
@@ -18,15 +17,18 @@ const execHelmInjectable = getInjectable({
     const helmBinaryPath = di.inject(helmBinaryPathInjectable);
 
     return async (args) => {
-      try {
-        const response = await execFile(helmBinaryPath, args, {
-          maxBuffer: 32 * 1024 * 1024 * 1024, // 32 MiB
-        });
+      const response = await execFile(helmBinaryPath, args, {
+        maxBuffer: 32 * 1024 * 1024 * 1024, // 32 MiB
+      });
 
-        return { callWasSuccessful: true, response };
-      } catch (error) {
-        return { callWasSuccessful: false, error: getErrorMessage(error) };
+      if (response.callWasSuccessful) {
+        return response;
       }
+
+      return {
+        callWasSuccessful: false,
+        error: response.error.stderr || response.error.error.message,
+      };
     };
   },
 });

src/main/helm/repositories/add-helm-repository/add-helm-repository-channel-listener.injectable.ts

@@ -2,25 +2,13 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable } from "@ogre-tools/injectable";
-import addHelmRepositoryChannelInjectable from "../../../../common/helm/add-helm-repository-channel.injectable";
+import { addHelmRepositoryChannel } from "../../../../common/helm/add-helm-repository-channel";
+import { getRequestChannelListenerInjectable } from "../../../utils/channel/channel-listeners/listener-tokens";
 import addHelmRepositoryInjectable from "./add-helm-repository.injectable";
-import { requestChannelListenerInjectionToken } from "../../../../common/utils/channel/request-channel-listener-injection-token";
 
-const addHelmRepositoryChannelListenerInjectable = getInjectable({
-  id: "add-helm-repository-channel-listener",
-
-  instantiate: (di) => {
-    const addHelmRepository = di.inject(addHelmRepositoryInjectable);
-    const channel = di.inject(addHelmRepositoryChannelInjectable);
-
-    return {
-      channel,
-      handler: addHelmRepository,
-    };
-  },
-
-  injectionToken: requestChannelListenerInjectionToken,
+const addHelmRepositoryChannelListenerInjectable = getRequestChannelListenerInjectable({
+  channel: addHelmRepositoryChannel,
+  handler: (di) => di.inject(addHelmRepositoryInjectable),
 });
 
 export default addHelmRepositoryChannelListenerInjectable;

src/main/helm/repositories/get-active-helm-repositories/get-active-helm-repositories-channel-listener.injectable.ts

@@ -2,25 +2,13 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable } from "@ogre-tools/injectable";
-import { requestChannelListenerInjectionToken } from "../../../../common/utils/channel/request-channel-listener-injection-token";
-import getActiveHelmRepositoriesChannelInjectable from "../../../../common/helm/get-active-helm-repositories-channel.injectable";
+import { getActiveHelmRepositoriesChannel } from "../../../../common/helm/get-active-helm-repositories-channel";
+import { getRequestChannelListenerInjectable } from "../../../utils/channel/channel-listeners/listener-tokens";
 import getActiveHelmRepositoriesInjectable from "./get-active-helm-repositories.injectable";
 
-const getActiveHelmRepositoriesChannelListenerInjectable = getInjectable({
-  id: "get-active-helm-repositories-channel-listener",
-
-  instantiate: (di) => {
-    const getActiveHelmRepositories = di.inject(getActiveHelmRepositoriesInjectable);
-
-    return {
-      channel: di.inject(getActiveHelmRepositoriesChannelInjectable),
-
-      handler: getActiveHelmRepositories,
-    };
-  },
-
-  injectionToken: requestChannelListenerInjectionToken,
+const getActiveHelmRepositoriesChannelListenerInjectable = getRequestChannelListenerInjectable({
+  channel: getActiveHelmRepositoriesChannel,
+  handler: (di) => di.inject(getActiveHelmRepositoriesInjectable),
 });
 
 export default getActiveHelmRepositoriesChannelListenerInjectable;

src/main/helm/repositories/remove-helm-repository/remove-helm-repository-channel-listener.injectable.ts

@@ -2,25 +2,13 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable } from "@ogre-tools/injectable";
-import { requestChannelListenerInjectionToken } from "../../../../common/utils/channel/request-channel-listener-injection-token";
 import removeHelmRepositoryInjectable from "./remove-helm-repository.injectable";
-import removeHelmRepositoryChannelInjectable from "../../../../common/helm/remove-helm-repository-channel.injectable";
+import { removeHelmRepositoryChannel } from "../../../../common/helm/remove-helm-repository-channel";
+import { getRequestChannelListenerInjectable } from "../../../utils/channel/channel-listeners/listener-tokens";
 
-const removeHelmRepositoryChannelListenerInjectable = getInjectable({
-  id: "remove-helm-repository-channel-listener",
-
-  instantiate: (di) => {
-    const removeHelmRepository = di.inject(removeHelmRepositoryInjectable);
-    const channel = di.inject(removeHelmRepositoryChannelInjectable);
-
-    return {
-      channel,
-      handler: removeHelmRepository,
-    };
-  },
-
-  injectionToken: requestChannelListenerInjectionToken,
+const removeHelmRepositoryChannelListenerInjectable = getRequestChannelListenerInjectable({
+  channel: removeHelmRepositoryChannel,
+  handler: (di) => di.inject(removeHelmRepositoryInjectable),
 });
 
 export default removeHelmRepositoryChannelListenerInjectable;

src/main/start-main-application/lens-window/application-window/create-electron-window.injectable.ts

@@ -6,7 +6,6 @@ import { getInjectable } from "@ogre-tools/injectable";
 import loggerInjectable from "../../../../common/logger.injectable";
 import applicationWindowStateInjectable from "./application-window-state.injectable";
 import { BrowserWindow } from "electron";
-import sendToChannelInElectronBrowserWindowInjectable from "./send-to-channel-in-electron-browser-window.injectable";
 import type { ElectronWindow } from "./create-lens-window.injectable";
 import type { RequireExactlyOne } from "type-fest";
 import openLinkInBrowserInjectable from "../../../../common/utils/open-link-in-browser.injectable";
@@ -45,7 +44,6 @@ const createElectronWindowInjectable = getInjectable({
 
   instantiate: (di): CreateElectronWindow => {
     const logger = di.inject(loggerInjectable);
-    const sendToChannelInLensWindow = di.inject(sendToChannelInElectronBrowserWindowInjectable);
     const openLinkInBrowser = di.inject(openLinkInBrowserInjectable);
 
     return (configuration) => {
@@ -140,7 +138,17 @@ const createElectronWindowInjectable = getInjectable({
 
         show: () => browserWindow.show(),
         close: () => browserWindow.close(),
-        send: (args) => sendToChannelInLensWindow(configuration.id, browserWindow, args),
+        send: ({ channel, data, frameInfo }) => {
+          if (frameInfo) {
+            browserWindow.webContents.sendToFrame(
+              [frameInfo.processId, frameInfo.frameId],
+              channel,
+              data,
+            );
+          } else {
+            browserWindow.webContents.send(channel, data);
+          }
+        },
 
         reload: () => {
           const wc = browserWindow.webContents;

src/main/start-main-application/lens-window/application-window/create-lens-window.injectable.ts

@@ -20,7 +20,7 @@ export interface ElectronWindow {
 export interface SendToViewArgs {
   channel: string;
   frameInfo?: ClusterFrameInfo;
-  data?: unknown[];
+  data?: unknown;
 }
 
 export interface LensWindow {

src/main/start-main-application/lens-window/application-window/send-to-channel-in-electron-browser-window.injectable.ts

@@ -1,33 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import type { BrowserWindow } from "electron";
-import type { SendToViewArgs } from "./create-lens-window.injectable";
-
-const sendToChannelInElectronBrowserWindowInjectable = getInjectable({
-  id: "send-to-channel-in-electron-browser-window",
-
-  instantiate:
-    () =>
-      (
-        windowId: string,
-        browserWindow: BrowserWindow,
-        { channel, frameInfo, data = [] }: SendToViewArgs,
-      ) => {
-        if (frameInfo) {
-          browserWindow.webContents.sendToFrame(
-            [frameInfo.processId, frameInfo.frameId],
-            channel,
-            ...data,
-          );
-        } else {
-          browserWindow.webContents.send(channel, ...data);
-        }
-      },
-
-  causesSideEffects: true,
-});
-
-export default sendToChannelInElectronBrowserWindowInjectable;

src/main/start-main-application/lens-window/navigate.injectable.ts

@@ -37,7 +37,7 @@ const navigateInjectable = getInjectable({
       applicationWindow.send({
         channel,
         frameInfo,
-        data: [url],
+        data: url,
       });
     };
   },

src/main/start-main-application/lens-window/reload-current-application-window.injectable.ts

@@ -3,9 +3,9 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { IpcRendererNavigationEvents } from "../../../renderer/navigation/events";
 import currentClusterFrameInjectable from "./current-cluster-frame/current-cluster-frame.injectable";
 import getCurrentApplicationWindowInjectable from "./application-window/get-current-application-window.injectable";
+import { reloadPageChannel } from "../../../features/navigation/reload-page/common/channel";
 
 const reloadCurrentApplicationWindowInjectable = getInjectable({
   id: "reload-current-application-window",
@@ -25,7 +25,7 @@ const reloadCurrentApplicationWindowInjectable = getInjectable({
 
       if (frameInfo) {
         lensWindow.send({
-          channel: IpcRendererNavigationEvents.RELOAD_PAGE,
+          channel: reloadPageChannel.id,
           frameInfo,
         });
       } else {

src/main/start-main-application/runnables/root-frame-has-rendered/channel-listener.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getMessageChannelListenerInjectable } from "../../../../common/utils/channel/message-channel-listener-injection-token";
+import { rootFrameHasRenderedChannel } from "../../../../common/root-frame/root-frame-rendered-channel";
+import { runManyFor } from "../../../../common/runnable/run-many-for";
+import { afterRootFrameIsReadyInjectionToken } from "../../runnable-tokens/after-root-frame-is-ready-injection-token";
+
+const rootFrameRenderedChannelListenerInjectable = getMessageChannelListenerInjectable({
+  id: "action",
+  channel: rootFrameHasRenderedChannel,
+  handler: (di) => {
+    const runMany = runManyFor(di);
+
+    return runMany(afterRootFrameIsReadyInjectionToken);
+  },
+});
+
+export default rootFrameRenderedChannelListenerInjectable;

src/main/start-main-application/runnables/root-frame-rendered-channel-listener/root-frame-rendered-channel-listener.injectable.ts

@@ -1,35 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import rootFrameRenderedChannelInjectable from "../../../../common/root-frame-rendered-channel/root-frame-rendered-channel.injectable";
-import { runManyFor } from "../../../../common/runnable/run-many-for";
-import { afterRootFrameIsReadyInjectionToken } from "../../runnable-tokens/after-root-frame-is-ready-injection-token";
-import { messageChannelListenerInjectionToken } from "../../../../common/utils/channel/message-channel-listener-injection-token";
-
-const rootFrameRenderedChannelListenerInjectable = getInjectable({
-  id: "root-frame-rendered-channel-listener",
-
-  instantiate: (di) => {
-    const channel = di.inject(rootFrameRenderedChannelInjectable);
-
-    const runMany = runManyFor(di);
-
-    const runRunnablesAfterRootFrameIsReady = runMany(
-      afterRootFrameIsReadyInjectionToken,
-    );
-
-    return {
-      channel,
-
-      handler: async () => {
-        await runRunnablesAfterRootFrameIsReady();
-      },
-    };
-  },
-
-  injectionToken: messageChannelListenerInjectionToken,
-});
-
-export default rootFrameRenderedChannelListenerInjectable;

src/main/utils/channel/channel-listeners/enlist-message-channel-listener.injectable.ts

@@ -6,8 +6,6 @@ import { getInjectable } from "@ogre-tools/injectable";
 import type { IpcMainEvent } from "electron";
 import ipcMainInjectable from "../ipc-main/ipc-main.injectable";
 import { enlistMessageChannelListenerInjectionToken } from "../../../../common/utils/channel/enlist-message-channel-listener-injection-token";
-import { pipeline } from "@ogre-tools/fp";
-import { tentativeParseJson } from "../../../../common/utils/tentative-parse-json";
 
 const enlistMessageChannelListenerInjectable = getInjectable({
   id: "enlist-message-channel-listener-for-main",
@@ -17,11 +15,7 @@ const enlistMessageChannelListenerInjectable = getInjectable({
 
     return ({ channel, handler }) => {
       const nativeOnCallback = (_: IpcMainEvent, message: unknown) => {
-        pipeline(
-          message,
-          tentativeParseJson,
-          handler,
-        );
+        handler(message);
       };
 
       ipcMain.on(channel.id, nativeOnCallback);

src/main/utils/channel/channel-listeners/enlist-message-channel-listener.test.ts

@@ -88,8 +88,8 @@ describe("enlist message channel listener in main", () => {
       expect(handlerMock).toHaveBeenCalledWith(true);
     });
 
-    it("given stringified object as message, when message arrives, calls the handler with the message", () => {
-      onMock.mock.calls[0][1]({} as IpcMainEvent, JSON.stringify({ some: "object" }));
+    it("given object as message, when message arrives, calls the handler with the message", () => {
+      onMock.mock.calls[0][1]({} as IpcMainEvent, { some: "object" });
 
       expect(handlerMock).toHaveBeenCalledWith({ some: "object" });
     });

src/main/utils/channel/channel-listeners/enlist-request-channel-listener.injectable.ts

@@ -5,20 +5,20 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import type { IpcMainInvokeEvent } from "electron";
 import ipcMainInjectable from "../ipc-main/ipc-main.injectable";
-import { enlistRequestChannelListenerInjectionToken } from "../../../../common/utils/channel/enlist-request-channel-listener-injection-token";
-import { pipeline } from "@ogre-tools/fp";
-import { tentativeParseJson } from "../../../../common/utils/tentative-parse-json";
-import { tentativeStringifyJson } from "../../../../common/utils/tentative-stringify-json";
+import type { Disposer } from "../../../../common/utils";
+import type { RequestChannel } from "../../../../common/utils/channel/request-channel-listener-injection-token";
+import type { RequestChannelListener } from "./listener-tokens";
+
+export type EnlistRequestChannelListener = <TChannel extends RequestChannel<unknown, unknown>>(listener: RequestChannelListener<TChannel>) => Disposer;
 
 const enlistRequestChannelListenerInjectable = getInjectable({
   id: "enlist-request-channel-listener-for-main",
 
-  instantiate: (di) => {
+  instantiate: (di): EnlistRequestChannelListener => {
     const ipcMain = di.inject(ipcMainInjectable);
 
     return ({ channel, handler }) => {
-      const nativeHandleCallback = (_: IpcMainInvokeEvent, request: unknown) =>
-        pipeline(request, tentativeParseJson, handler, tentativeStringifyJson);
+      const nativeHandleCallback = (_: IpcMainInvokeEvent, request: unknown) => handler(request);
 
       ipcMain.handle(channel.id, nativeHandleCallback);
 
@@ -27,8 +27,6 @@ const enlistRequestChannelListenerInjectable = getInjectable({
       };
     };
   },
-
-  injectionToken: enlistRequestChannelListenerInjectionToken,
 });
 
 export default enlistRequestChannelListenerInjectable;

src/main/utils/channel/channel-listeners/enlist-request-channel-listener.test.ts

@@ -5,11 +5,19 @@
 import { getDiForUnitTesting } from "../../../getDiForUnitTesting";
 import ipcMainInjectable from "../ipc-main/ipc-main.injectable";
 import type { IpcMain, IpcMainInvokeEvent } from "electron";
-import type { EnlistRequestChannelListener } from "../../../../common/utils/channel/enlist-request-channel-listener-injection-token";
-import { enlistRequestChannelListenerInjectionToken } from "../../../../common/utils/channel/enlist-request-channel-listener-injection-token";
 import { getPromiseStatus } from "../../../../common/test-utils/get-promise-status";
 import type { AsyncFnMock } from "@async-fn/jest";
 import asyncFn from "@async-fn/jest";
+import type { RequestChannel } from "../../../../common/utils/channel/request-channel-listener-injection-token";
+import type { EnlistRequestChannelListener } from "./enlist-request-channel-listener.injectable";
+import enlistRequestChannelListenerInjectable from "./enlist-request-channel-listener.injectable";
+import type { RequestChannelHandler } from "./listener-tokens";
+
+type TestRequestChannel = RequestChannel<unknown, unknown>;
+
+const testRequestChannel: TestRequestChannel = {
+  id: "some-channel-id",
+};
 
 describe("enlist request channel listener in main", () => {
   let enlistRequestChannelListener: EnlistRequestChannelListener;
@@ -30,20 +38,18 @@ describe("enlist request channel listener in main", () => {
 
     di.override(ipcMainInjectable, () => ipcMainStub);
 
-    enlistRequestChannelListener = di.inject(
-      enlistRequestChannelListenerInjectionToken,
-    );
+    enlistRequestChannelListener = di.inject(enlistRequestChannelListenerInjectable);
   });
 
   describe("when called", () => {
-    let handlerMock: AsyncFnMock<(message: any) => any>;
+    let handlerMock: AsyncFnMock<RequestChannelHandler<TestRequestChannel>>;
     let disposer: () => void;
 
     beforeEach(() => {
       handlerMock = asyncFn();
 
       disposer = enlistRequestChannelListener({
-        channel: { id: "some-channel-id" },
+        channel: testRequestChannel,
         handler: handlerMock,
       });
     });
@@ -91,7 +97,7 @@ describe("enlist request channel listener in main", () => {
         it("resolves with the response", async () => {
           const actual = await actualPromise;
 
-          expect(actual).toBe('"some-response"');
+          expect(actual).toBe("some-response");
         });
 
         it("when disposing the listener, de-registers the listener", () => {
@@ -106,7 +112,7 @@ describe("enlist request channel listener in main", () => {
 
         const actual = await actualPromise;
 
-        expect(actual).toBe("42");
+        expect(actual).toBe(42);
       });
 
       it("given boolean as response, when handler resolves with response, listener resolves with stringified response", async () => {
@@ -114,15 +120,15 @@ describe("enlist request channel listener in main", () => {
 
         const actual = await actualPromise;
 
-        expect(actual).toBe("true");
+        expect(actual).toBe(true);
       });
 
-      it("given object as response, when handler resolves with response, listener resolves with stringified response", async () => {
+      it("given object as response, when handler resolves with response, listener resolves with response", async () => {
         await handlerMock.resolve({ some: "object" });
 
         const actual = await actualPromise;
 
-        expect(actual).toBe(JSON.stringify({ some: "object" }));
+        expect(actual).toEqual({ some: "object" });
       });
     });
 
@@ -138,8 +144,8 @@ describe("enlist request channel listener in main", () => {
       expect(handlerMock).toHaveBeenCalledWith(true);
     });
 
-    it("given stringified object as request, when request arrives, calls the handler with the request", () => {
-      handleMock.mock.calls[0][1]({} as IpcMainInvokeEvent, JSON.stringify({ some: "object" }));
+    it("given object as request, when request arrives, calls the handler with the request", () => {
+      handleMock.mock.calls[0][1]({} as IpcMainInvokeEvent, { some: "object" });
 
       expect(handlerMock).toHaveBeenCalledWith({ some: "object" });
     });

src/main/utils/channel/channel-listeners/listener-tokens.ts

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import type { DiContainerForInjection } from "@ogre-tools/injectable";
+import { getInjectable, getInjectionToken } from "@ogre-tools/injectable";
+import type { RequestChannel } from "../../../../common/utils/channel/request-channel-listener-injection-token";
+
+export type RequestChannelHandler<Channel> = Channel extends RequestChannel<infer Request, infer Response>
+  ? (req: Request) => Promise<Response> | Response
+  : never;
+
+export interface RequestChannelListener<Channel> {
+  channel: Channel;
+  handler: RequestChannelHandler<Channel>;
+}
+
+
+export const requestChannelListenerInjectionToken = getInjectionToken<RequestChannelListener<RequestChannel<unknown, unknown>>>( {
+  id: "request-channel-listener",
+});
+
+export interface GetRequestChannelListenerInjectableInfo<
+  Channel extends RequestChannel<Request, Response>,
+  Request,
+  Response,
+> {
+  channel: Channel;
+  handler: (di: DiContainerForInjection) => RequestChannelHandler<Channel>;
+}
+
+export function getRequestChannelListenerInjectable<
+  Channel extends RequestChannel<Request, Response>,
+  Request,
+  Response,
+>(info: GetRequestChannelListenerInjectableInfo<Channel, Request, Response>) {
+  return getInjectable({
+    id: `${info.channel.id}-listener`,
+    instantiate: (di) => ({
+      channel: info.channel,
+      handler: info.handler(di),
+    }),
+    injectionToken: requestChannelListenerInjectionToken,
+  });
+}

src/main/utils/channel/channel-listeners/listening-on-request-channels.injectable.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { disposer } from "../../../../common/utils";
+import type { RequestChannel } from "../../../../common/utils/channel/request-channel-listener-injection-token";
+import { getStartableStoppable } from "../../../../common/utils/get-startable-stoppable";
+import enlistRequestChannelListenerInjectable from "./enlist-request-channel-listener.injectable";
+import { requestChannelListenerInjectionToken } from "./listener-tokens";
+
+const listeningOnRequestChannelsInjectable = getInjectable({
+  id: "listening-on-request-channels",
+  instantiate: (di) => {
+    const enlistRequestChannelListener = di.inject(enlistRequestChannelListenerInjectable);
+    const requestChannelListeners = di.injectMany(requestChannelListenerInjectionToken);
+
+    return getStartableStoppable("listening-on-request-channels", () => {
+      const seenChannels = new Set<RequestChannel<unknown, unknown>>();
+
+      for (const listener of requestChannelListeners) {
+        if (seenChannels.has(listener.channel)) {
+          throw new Error(`Tried to register a multiple channel handlers for "${listener.channel.id}", only one handler is supported for a request channel.`);
+        }
+
+        seenChannels.add(listener.channel);
+      }
+
+      return disposer(requestChannelListeners.map(enlistRequestChannelListener));
+    });
+  },
+});
+
+export default listeningOnRequestChannelsInjectable;

src/main/utils/channel/channel-listeners/start-listening-of-channels.injectable.ts

@@ -1,26 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import { onLoadOfApplicationInjectionToken } from "../../../start-main-application/runnable-tokens/on-load-of-application-injection-token";
-import listeningOfChannelsInjectable from "../../../../common/utils/channel/listening-of-channels.injectable";
-
-const startListeningOfChannelsInjectable = getInjectable({
-  id: "start-listening-of-channels-main",
-
-  instantiate: (di) => {
-    const listeningOfChannels = di.inject(listeningOfChannelsInjectable);
-
-    return {
-      id: "start-listening-of-channels-main",
-      run: async () => {
-        await listeningOfChannels.start();
-      },
-    };
-  },
-
-  injectionToken: onLoadOfApplicationInjectionToken,
-});
-
-export default startListeningOfChannelsInjectable;

src/main/utils/channel/channel-listeners/start-listening-on-channels.injectable.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { onLoadOfApplicationInjectionToken } from "../../../start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import listeningOnMessageChannelsInjectable from "../../../../common/utils/channel/listening-on-message-channels.injectable";
+import listeningOnRequestChannelsInjectable from "./listening-on-request-channels.injectable";
+
+const startListeningOnChannelsInjectable = getInjectable({
+  id: "start-listening-on-channels-main",
+
+  instantiate: (di) => {
+    const listeningOnMessageChannels = di.inject(listeningOnMessageChannelsInjectable);
+    const listeningOnRequestChannels = di.inject(listeningOnRequestChannelsInjectable);
+
+    return {
+      id: "start-listening-on-channels-main",
+      run: async () => {
+        await listeningOnMessageChannels.start();
+        await listeningOnRequestChannels.start();
+      },
+    };
+  },
+
+  injectionToken: onLoadOfApplicationInjectionToken,
+});
+
+export default startListeningOnChannelsInjectable;

src/main/utils/channel/message-to-channel.injectable.ts

@@ -3,9 +3,8 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { messageToChannelInjectionToken } from "../../../common/utils/channel/message-to-channel-injection-token";
-import type { MessageChannel } from "../../../common/utils/channel/message-channel-injection-token";
-import { tentativeStringifyJson } from "../../../common/utils/tentative-stringify-json";
+import type { SendMessageToChannel } from "../../../common/utils/channel/message-to-channel-injection-token";
+import { sendMessageToChannelInjectionToken } from "../../../common/utils/channel/message-to-channel-injection-token";
 import getVisibleWindowsInjectable from "../../start-main-application/lens-window/get-visible-windows.injectable";
 
 const messageToChannelInjectable = getInjectable({
@@ -14,18 +13,14 @@ const messageToChannelInjectable = getInjectable({
   instantiate: (di) => {
     const getVisibleWindows = di.inject(getVisibleWindowsInjectable);
 
-    // TODO: Figure out way to improve typing in internals
-    // Notice that this should be injected using "messageToChannelInjectionToken" which is typed correctly.
-    return (channel: MessageChannel<any>, message?: unknown) => {
-      const stringifiedMessage = tentativeStringifyJson(message);
-
-      getVisibleWindows().forEach((lensWindow) =>
-        lensWindow.send({ channel: channel.id, data: stringifiedMessage ? [stringifiedMessage] : [] }),
-      );
-    };
+    return ((channel, data) => {
+      for (const window of getVisibleWindows()) {
+        window.send({ channel: channel.id, data });
+      }
+    }) as SendMessageToChannel;
   },
 
-  injectionToken: messageToChannelInjectionToken,
+  injectionToken: sendMessageToChannelInjectionToken,
 });
 
 export default messageToChannelInjectable;

src/main/utils/channel/message-to-channel.test.ts

@@ -1,148 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { MessageToChannel } from "../../../common/utils/channel/message-to-channel-injection-token";
-import { messageToChannelInjectionToken } from "../../../common/utils/channel/message-to-channel-injection-token";
-import type { MessageChannel } from "../../../common/utils/channel/message-channel-injection-token";
-import type { LensWindow } from "../../start-main-application/lens-window/application-window/create-lens-window.injectable";
-import sendToChannelInElectronBrowserWindowInjectable from "../../start-main-application/lens-window/application-window/send-to-channel-in-electron-browser-window.injectable";
-import { getApplicationBuilder } from "../../../renderer/components/test-utils/get-application-builder";
-
-describe("message to channel from main", () => {
-  let messageToChannel: MessageToChannel;
-  let someTestWindow: LensWindow;
-  let someOtherTestWindow: LensWindow;
-  let sendToChannelInBrowserMock: jest.Mock;
-
-  beforeEach(async () => {
-    const builder = getApplicationBuilder();
-
-    sendToChannelInBrowserMock = jest.fn();
-
-    builder.beforeApplicationStart(mainDi => {
-      mainDi.override(sendToChannelInElectronBrowserWindowInjectable, () => sendToChannelInBrowserMock);
-    });
-
-    await builder.startHidden();
-
-    someTestWindow = builder.applicationWindow.create("some-test-window-id");
-    someOtherTestWindow = builder.applicationWindow.create("some-other-test-window-id");
-
-    messageToChannel = builder.mainDi.inject(messageToChannelInjectionToken);
-  });
-
-  it("given no visible windows, when messaging to channel, does not message to any window", () => {
-    messageToChannel(someChannel, "some-message");
-
-    expect(sendToChannelInBrowserMock).not.toHaveBeenCalled();
-  });
-
-  describe("given started window", () => {
-    beforeEach(async () => {
-      await someTestWindow.start();
-    });
-
-    it("when messaging to channel, messages to window", () => {
-      messageToChannel(someChannel, "some-message");
-
-      expect(sendToChannelInBrowserMock.mock.calls).toEqual([
-        [
-          "some-test-window-id",
-
-          null,
-
-          {
-            channel: "some-channel",
-            data: ['"some-message"'],
-          },
-        ],
-      ]);
-    });
-
-    it("given boolean as message, when messaging to channel, messages to window with stringified message", () => {
-      messageToChannel(someChannel, true);
-
-      expect(sendToChannelInBrowserMock.mock.calls).toEqual([
-        [
-          "some-test-window-id",
-
-          null,
-
-          {
-            channel: "some-channel",
-            data: ["true"],
-          },
-        ],
-      ]);
-    });
-
-    it("given number as message, when messaging to channel, messages to window with stringified message", () => {
-      messageToChannel(someChannel, 42);
-
-      expect(sendToChannelInBrowserMock.mock.calls).toEqual([
-        [
-          "some-test-window-id",
-
-          null,
-
-          {
-            channel: "some-channel",
-            data: ["42"],
-          },
-        ],
-      ]);
-    });
-
-    it("given object as message, when messaging to channel, messages to window with stringified message", () => {
-      messageToChannel(someChannel, { some: "object" });
-
-      expect(sendToChannelInBrowserMock.mock.calls).toEqual([
-        [
-          "some-test-window-id",
-
-          null,
-
-          {
-            channel: "some-channel",
-            data: [JSON.stringify({ some: "object" })],
-          },
-        ],
-      ]);
-    });
-  });
-
-  it("given multiple started windows, when messaging to channel, messages to window", async () => {
-    await someTestWindow.start();
-    await someOtherTestWindow.start();
-
-    messageToChannel(someChannel, "some-message");
-
-    expect(sendToChannelInBrowserMock.mock.calls).toEqual([
-      [
-        "some-test-window-id",
-
-        null,
-
-        {
-          channel: "some-channel",
-          data: ['"some-message"'],
-        },
-      ],
-
-      [
-        "some-other-test-window-id",
-
-        null,
-
-        {
-          channel: "some-channel",
-          data: ['"some-message"'],
-        },
-      ],
-    ]);
-  });
-});
-
-const someChannel: MessageChannel<any> = { id: "some-channel" };

src/main/utils/resolve-system-proxy/resolve-system-proxy-channel-responder.injectable.ts

@@ -2,20 +2,13 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable } from "@ogre-tools/injectable";
-import resolveSystemProxyChannelInjectable from "../../../common/utils/resolve-system-proxy/resolve-system-proxy-channel.injectable";
+import { resolveSystemProxyChannel } from "../../../common/utils/resolve-system-proxy/resolve-system-proxy-channel";
+import { getRequestChannelListenerInjectable } from "../channel/channel-listeners/listener-tokens";
 import resolveSystemProxyInjectable from "./resolve-system-proxy.injectable";
-import { requestChannelListenerInjectionToken } from "../../../common/utils/channel/request-channel-listener-injection-token";
 
-const resolveSystemProxyChannelResponderInjectable = getInjectable({
-  id: "resolve-system-proxy-channel-responder",
-
-  instantiate: (di) => ({
-    channel: di.inject(resolveSystemProxyChannelInjectable),
-    handler: di.inject(resolveSystemProxyInjectable),
-  }),
-
-  injectionToken: requestChannelListenerInjectionToken,
+const resolveSystemProxyChannelResponderInjectable = getRequestChannelListenerInjectable({
+  channel: resolveSystemProxyChannel,
+  handler: (di) => di.inject(resolveSystemProxyInjectable),
 });
 
 export default resolveSystemProxyChannelResponderInjectable;

src/main/utils/sync-box/sync-box-initial-value-channel-listener.injectable.ts

@@ -2,30 +2,20 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable } from "@ogre-tools/injectable";
-import syncBoxInitialValueChannelInjectable from "../../../common/utils/sync-box/sync-box-initial-value-channel.injectable";
+import { syncBoxInitialValueChannel } from "../../../common/utils/sync-box/channels";
 import { syncBoxInjectionToken } from "../../../common/utils/sync-box/sync-box-injection-token";
-import { requestChannelListenerInjectionToken } from "../../../common/utils/channel/request-channel-listener-injection-token";
+import { getRequestChannelListenerInjectable } from "../channel/channel-listeners/listener-tokens";
 
-const syncBoxInitialValueChannelListenerInjectable = getInjectable({
-  id: "sync-box-initial-value-channel-listener",
-
-  instantiate: (di) => {
-    const channel = di.inject(syncBoxInitialValueChannelInjectable);
+const syncBoxInitialValueChannelListenerInjectable = getRequestChannelListenerInjectable({
+  channel: syncBoxInitialValueChannel,
+  handler: (di) => {
     const syncBoxes = di.injectMany(syncBoxInjectionToken);
 
-    return {
-      channel,
-
-      handler: () =>
-        syncBoxes.map((box) => ({
-          id: box.id,
-          value: box.value.get(),
-        })),
-    };
+    return () => syncBoxes.map((box) => ({
+      id: box.id,
+      value: box.value.get(),
+    }));
   },
-
-  injectionToken: requestChannelListenerInjectionToken,
 });
 
 export default syncBoxInitialValueChannelListenerInjectable;