fix: utility process is a improper name for the browser window

packages/insomnia-smoke-test/tests/smoke/pre-request-script.test.ts

@@ -2,7 +2,7 @@ import { expect } from '@playwright/test';
 
 import { test } from '../../playwright/test';;
 
-test.describe('test utility process', async () => {
+test.describe('test pre-request script execution', async () => {
 
   const testCases = [
     {
@@ -315,12 +315,13 @@ test.describe('test utility process', async () => {
 
       const originalWindowCount = app.windows().length;
 
-      // start the utility process
+      // start the sandbox
       await mainWindow?.evaluate(
         async () => {
-          const caller = window as unknown as { utilityProcess: { start: () => void } };
-          if (caller.utilityProcess) {
-            caller.utilityProcess.start();
+          // it suppresses the type checking error
+          const caller = window as unknown as { hiddenBrowserWindow: { start: () => void } };
+          if (caller.hiddenBrowserWindow) {
+            caller.hiddenBrowserWindow.start();
           }
         },
       );
@@ -331,13 +332,13 @@ test.describe('test utility process', async () => {
         if (windows.length > originalWindowCount) {
           for (const page of windows) {
             const title = await page.title();
-            if (title === 'Utility Process') {
+            if (title === 'Hidden Browser Window') {
               await page.waitForLoadState();
             }
           }
           break;
         }
-        mainWindow.waitForTimeout(500);
+        await mainWindow.waitForTimeout(500);
       }
 
       // action
@@ -345,7 +346,7 @@ test.describe('test utility process', async () => {
         async (tc: any) => {
           window.postMessage(
             {
-              action: 'message-event://utility.process/debug',
+              action: 'message-event://hidden.browser-window/debug',
               id: tc.id,
               code: tc.code,
               context: tc.context,
@@ -368,9 +369,11 @@ test.describe('test utility process', async () => {
         if (localStorage[`test_result:${tc.id}`] || localStorage[`test_error:${tc.id}`]) {
           break;
         }
-        mainWindow.waitForTimeout(500);
+        await mainWindow.waitForTimeout(500);
       }
 
+      // await mainWindow.waitForTimeout(300000);
+
       if (localStorage) { // just for suppressing ts complaint
         console.log(localStorage[`test_error:${tc.id}`]);
         expect(JSON.parse(localStorage[`test_result:${tc.id}`])).toEqual(tc.expectedResult);

packages/insomnia/.gitignore

@@ -6,5 +6,5 @@ src/main.min.js
 src/main.min.js.map
 src/preload.js
 src/preload.js.map
-src/renderers/utility-process/**/*.js
-src/renderers/utility-process/**/*.js.map
+src/renderers/hidden-browser-window/**/*.js
+src/renderers/hidden-browser-window/**/*.js.map

packages/insomnia/esbuild.main.ts

@@ -22,8 +22,8 @@ export default async function build(options: Options) {
       'process.env.APP_RENDER_URL': JSON.stringify(
         `http://localhost:${PORT}/index.html`
       ),
-      'process.env.UTILITY_PROCESS_URL': JSON.stringify(
-        `http://localhost:${PORT}/renderers/utility-process/index.html`
+      'process.env.HIDDEN_BROWSER_WINDOW_URL': JSON.stringify(
+        `http://localhost:${PORT}/renderers/hidden-browser-window/index.html`
       ),
       'process.env.NODE_ENV': JSON.stringify('development'),
       'process.env.INSOMNIA_ENV': JSON.stringify('development'),
@@ -44,9 +44,9 @@ export default async function build(options: Options) {
     format: 'cjs',
     external: ['electron'],
   });
-  const preloadUtilityProcess = esbuild.build({
-    entryPoints: ['./src/renderers/utility-process/preload.ts'],
-    outfile: path.join(outdir, 'renderers/utility-process/preload-utility-process.js'),
+  const preloadHiddenBrowserWindow = esbuild.build({
+    entryPoints: ['./src/renderers/hidden-browser-window/preload.ts'],
+    outfile: path.join(outdir, 'renderers/hidden-browser-window/preload-hidden-browser-window.js'),
     target: 'esnext',
     bundle: true,
     platform: 'node',
@@ -54,10 +54,10 @@ export default async function build(options: Options) {
     format: 'cjs',
     external: ['electron'],
   });
-  const utilityProcess = esbuild.build({
-    entryPoints: ['./src/renderers/utility-process/index.ts'],
-    // utility process is always outputed to 'src' as index.html requires a built bundle
-    outfile: path.join(__dirname, 'src', 'renderers/utility-process/utility-process.js'),
+  const hiddenBrowserWindow = esbuild.build({
+    entryPoints: ['./src/renderers/hidden-browser-window/index.ts'],
+    // the hidden browser window script is always outputed to 'src' as index.html requires a built bundle
+    outfile: path.join(__dirname, 'src', 'renderers/hidden-browser-window/index.js'),
     target: 'esnext',
     bundle: true,
     platform: 'browser',
@@ -81,7 +81,7 @@ export default async function build(options: Options) {
     ],
   });
 
-  return Promise.all([main, preload, preloadUtilityProcess, utilityProcess]);
+  return Promise.all([main, preload, preloadHiddenBrowserWindow, hiddenBrowserWindow]);
 }
 
 // Build if ran as a cli script

packages/insomnia/src/global.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="vite/client" />
+import type { HiddenBrowserWindowAPI } from './main/ipc/hidden-browser-window';
 import type { MainBridgeAPI } from './main/ipc/main';
-import type { UtilityProcessAPI } from './main/ipc/utility-process';
 
 declare global {
   interface Window {
@@ -9,7 +9,7 @@ declare global {
     app: Pick<Electron.App, 'getPath' | 'getAppPath'>;
     shell: Pick<Electron.Shell, 'showItemInFolder'>;
     clipboard: Pick<Electron.Clipboard, 'readText' | 'writeText' | 'clear'>;
-    utilityProcess: UtilityProcessAPI;
+    hiddenBrowserWindow: HiddenBrowserWindowAPI;
   }
 }
 

packages/insomnia/src/main/ipc/hidden-browser-window.ts

@@ -0,0 +1,22 @@
+import { BrowserWindow, ipcMain } from 'electron';
+
+import { createHiddenBrowserWindow } from '../window-utils';
+
+export interface HiddenBrowserWindowAPI {
+    start: () => void;
+}
+
+// registerHiddenBrowserWindowConsumer broadcasts message ports to observer windows
+export function registerHiddenBrowserWindowConsumer(consumerWindows: BrowserWindow[]) {
+    ipcMain.on('ipc://main/publish-port', ev => {
+        consumerWindows.forEach(win => {
+            win.webContents.postMessage('ipc://renderers/publish-port', null, ev.ports);
+        });
+    });
+}
+
+export function registerHiddenBrowserWindowController() {
+    ipcMain.handle('ipc://main/hidden-browser-window/start', () => {
+        createHiddenBrowserWindow();
+    });
+}

packages/insomnia/src/main/ipc/utility-process.ts

@@ -1,22 +0,0 @@
-import { BrowserWindow, ipcMain } from 'electron';
-
-import { createUtilityProcess } from '../window-utils';
-
-export interface UtilityProcessAPI {
-    start: () => void;
-}
-
-// registerUtilityProcessPort broadcasts message ports to observer windows
-export function registerUtilityProcessConsumer(consumerWindows: BrowserWindow[]) {
-    ipcMain.on('ipc://main/publish-port', ev => {
-        consumerWindows.forEach(win => {
-            win.webContents.postMessage('ipc://renderers/publish-port', null, ev.ports);
-        });
-    });
-}
-
-export function registerUtilityProcessController() {
-    ipcMain.handle('ipc://main/utility-process/start', () => {
-        createUtilityProcess();
-    });
-}

packages/insomnia/src/main/window-utils.ts

@@ -16,7 +16,7 @@ import {
 } from '../common/constants';
 import { docsBase } from '../common/documentation';
 import * as log from '../common/log';
-import { registerUtilityProcessConsumer, registerUtilityProcessController } from './ipc/utility-process';
+import { registerHiddenBrowserWindowConsumer, registerHiddenBrowserWindowController } from './ipc/hidden-browser-window';
 import LocalStorage from './local-storage';
 
 const { app, Menu, shell, dialog, clipboard, BrowserWindow } = electron;
@@ -27,7 +27,7 @@ const MINIMUM_WIDTH = 500;
 const MINIMUM_HEIGHT = 400;
 
 let newWindow: ElectronBrowserWindow | null = null;
-let isolatedUtilityProcess: ElectronBrowserWindow | null = null;
+let hiddenBrowserWindow: ElectronBrowserWindow | null = null;
 const windows = new Set<ElectronBrowserWindow>();
 const processes = new Set<ElectronBrowserWindow>();
 let localStorage: LocalStorage | null = null;
@@ -43,35 +43,35 @@ export function init() {
   initLocalStorage();
 }
 
-export function createUtilityProcess() {
-  isolatedUtilityProcess = new BrowserWindow({
+export function createHiddenBrowserWindow() {
+  hiddenBrowserWindow = new BrowserWindow({
     show: false,
-    title: 'UtilityProcess',
+    title: 'HiddenBrowserWindow',
     webPreferences: {
       sandbox: true,
       contextIsolation: true,
       nodeIntegration: false,
       webSecurity: true,
-      preload: path.join(__dirname, 'renderers/utility-process/preload-utility-process.js'),
+      preload: path.join(__dirname, 'renderers/hidden-browser-window/preload-hidden-browser-window.js'),
       spellcheck: false,
     },
   });
 
-  const utilityProcessPath = path.resolve(__dirname, './renderers/utility-process/index.html');
-  const utilityProcessUrl = process.env.UTILITY_PROCESS_URL || pathToFileURL(utilityProcessPath).href;
-  console.log('[main] loading utility process:', process.env.UTILITY_PROCESS_URL, pathToFileURL(utilityProcessPath).href);
-  isolatedUtilityProcess.loadURL(utilityProcessUrl);
+  const hiddenBrowserWindowPath = path.resolve(__dirname, './renderers/hidden-browser-window/index.html');
+  const hiddenBrowserWindowUrl = process.env.HIDDEN_BROWSER_WINDOW_URL || pathToFileURL(hiddenBrowserWindowPath).href;
+  hiddenBrowserWindow.loadURL(hiddenBrowserWindowUrl);
+  console.log('[main] loading hidden browser window:', process.env.HIDDEN_BROWSER_WINDOW_URL, pathToFileURL(hiddenBrowserWindowPath).href);
 
-  isolatedUtilityProcess?.on('closed', () => {
-    if (isolatedUtilityProcess) {
-      processes.delete(isolatedUtilityProcess);
-      isolatedUtilityProcess = processes.values().next().value || null;
+  hiddenBrowserWindow?.on('closed', () => {
+    if (hiddenBrowserWindow) {
+      processes.delete(hiddenBrowserWindow);
+      hiddenBrowserWindow = processes.values().next().value || null;
     }
   });
 
-  processes.add(isolatedUtilityProcess);
+  processes.add(hiddenBrowserWindow);
 
-  return isolatedUtilityProcess;
+  return hiddenBrowserWindow;
 }
 
 export function createWindow() {
@@ -476,9 +476,10 @@ export function createWindow() {
     );
   } else {
     // @ts-expect-error -- TSCONVERSION type splitting
-    helpMenu.submenu?.push({
-      type: 'separator',
-    },
+    helpMenu.submenu?.push(
+      {
+        type: 'separator',
+      },
       {
         label: `${MNEMONIC_SYM}About`,
         click: aboutMenuClickHandler,
@@ -582,8 +583,8 @@ export function createWindow() {
   Menu.setApplicationMenu(Menu.buildFromTemplate(template));
   windows.add(newWindow);
 
-  registerUtilityProcessController();
-  registerUtilityProcessConsumer(windows ? Array.from(windows.values()) : []);
+  registerHiddenBrowserWindowController();
+  registerHiddenBrowserWindowConsumer(windows ? Array.from(windows.values()) : []);
 
   return newWindow;
 }

packages/insomnia/src/preload.ts

@@ -87,8 +87,8 @@ const clipboard: Window['clipboard'] = {
   clear: () => ipcRenderer.send('clear'),
 };
 
-const utilityProcess: Window['utilityProcess'] = {
-  start: () => ipcRenderer.invoke('ipc://main/utility-process/start'),
+const hiddenBrowserWindow: Window['hiddenBrowserWindow'] = {
+  start: () => ipcRenderer.invoke('ipc://main/hidden-browser-window/start'),
 };
 
 if (process.contextIsolated) {
@@ -97,14 +97,14 @@ if (process.contextIsolated) {
   contextBridge.exposeInMainWorld('app', app);
   contextBridge.exposeInMainWorld('shell', shell);
   contextBridge.exposeInMainWorld('clipboard', clipboard);
-  contextBridge.exposeInMainWorld('utilityProcess', utilityProcess);
+  contextBridge.exposeInMainWorld('hiddenBrowserWindow', hiddenBrowserWindow);
 } else {
   window.main = main;
   window.dialog = dialog;
   window.app = app;
   window.shell = shell;
   window.clipboard = clipboard;
-  window.utilityProcess = utilityProcess;
+  window.hiddenBrowserWindow = hiddenBrowserWindow;
 }
 
 // it is different from window.main.on, it requires events to pass ports

packages/insomnia/src/renderers/hidden-browser-window/index.html

@@ -6,11 +6,11 @@
       http-equiv="Content-Security-Policy"
       content="font-src 'self' data:; connect-src * data: api: insomnia-event-source:; default-src * insomnia://*; img-src blob: data: * insomnia://*; script-src 'self' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; media-src blob: data: mediastream: * insomnia://*;"
     />
-    <title>Utility Process</title>
+    <title>Hidden Browser Window</title>
   </head>
 
   <body>
-    <h1>Utility Process</h1>
-    <script src="./utility-process.js" type="module"></script>
+    <h1>>Hidden Browser Window</h1>
+    <script src="./index.js" type="module"></script>
   </body>
 </html>

packages/insomnia/src/renderers/hidden-browser-window/index.ts

@@ -1,6 +1,6 @@
 import { initPm } from './inso-object';
 
-const executeAction = 'message-port://utility.process/execute';
+const executeAction = 'message-port://hidden.browser-window/execute';
 
 async function init() {
     const channel = new MessageChannel();
@@ -8,7 +8,7 @@ async function init() {
     channel.port1.onmessage = async (ev: MessageEvent) => {
         const action = ev.data.action;
 
-        if (action === executeAction || action === 'message-port://utility.process/debug') {
+        if (action === executeAction || action === 'message-port://hidden.browser-window/debug') {
             try {
                 const getPm = new Function('pm', 'return pm;');
                 const rawPm = getPm(ev.data.options.context.pm);

packages/insomnia/src/ui/window-message-handlers.ts

@@ -2,7 +2,7 @@
 type MessageHandler = (ev: MessageEvent) => Promise<void>;
 
 class WindowMessageHandler {
-    private utilityProcessPort: MessagePort | undefined;
+    private hiddenBrowserWindowPort: MessagePort | undefined;
     private actionHandlers: Map<string, MessageHandler> = new Map();
 
     constructor() { }
@@ -13,12 +13,12 @@ class WindowMessageHandler {
             return;
         }
 
-        this.utilityProcessPort = ev.ports[0];
+        this.hiddenBrowserWindowPort = ev.ports[0];
 
-        this.utilityProcessPort.onmessage = ev => {
+        this.hiddenBrowserWindowPort.onmessage = ev => {
             if (ev.data.action === 'message-port://caller/respond') {
                 // TODO: hook to UI and display result
-                console.log('[main] result from utility process:', ev.data.result);
+                console.log('[main] result from hidden browser window:', ev.data.result);
             } else if (ev.data.action === 'message-port://caller/debug/respond') {
                 if (ev.data.result) {
                     window.localStorage.setItem(`test_result:${ev.data.id}`, JSON.stringify(ev.data.result));
@@ -32,13 +32,13 @@ class WindowMessageHandler {
     };
 
     debugEventHandler = async (ev: MessageEvent) => {
-        if (!this.utilityProcessPort) {
-            console.error('utility process port is not inited');
+        if (!this.hiddenBrowserWindowPort) {
+            console.error('hidden browser window port is not inited');
             return;
         }
 
-        this.utilityProcessPort.postMessage({
-            action: 'message-port://utility.process/debug',
+        this.hiddenBrowserWindowPort.postMessage({
+            action: 'message-port://hidden.browser-window/debug',
             options: {
                 id: ev.data.id,
                 code: ev.data.code,
@@ -47,16 +47,13 @@ class WindowMessageHandler {
         });
     };
 
-    // startUtilityProcessHandler = async (ev: MessageEvent) => {
-    // };
-
     register = (actionName: string, handler: MessageHandler) => {
         this.actionHandlers.set(actionName, handler);
     };
 
     start = () => {
         this.register('message-event://renderers/publish-port', this.publishPortHandler);
-        this.register('message-event://utility.process/debug', this.debugEventHandler);
+        this.register('message-event://hidden.browser-window/debug', this.debugEventHandler);
 
         window.onmessage = (ev: MessageEvent) => {
             const action = ev.data.action;

packages/insomnia/vite.config.ts

@@ -33,7 +33,7 @@ export default defineConfig(({ mode }) => {
       rollupOptions: {
         input: {
           main: path.join(__dirname, 'src/index.html'),
-          utilityProcess: path.join(__dirname, 'src/renderers/utility-process/index.html'),
+          hiddenBrowserWindow: path.join(__dirname, 'src/renderers/hidden-browser-window/index.html'),
         },
         external: ['@getinsomnia/node-libcurl'],
       },