@minded-ai/mindedjs 1.0.0-ec2-beta-1

package/src/browserTask/executeBrowserTask.py

@@ -0,0 +1,153 @@
+import asyncio
+import json
+from typing import List, Optional, Dict, Any, TypedDict
+from pydantic import BaseModel, create_model, Field
+from browser_use import Agent, Controller, ActionResult
+from browser_use.browser import BrowserProfile, BrowserSession
+from browser_use.llm import ChatOpenAI
+import os
+import sys
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class OutputSchemaItemRequired(TypedDict):
+  name: str
+  type: str  # 'string' | 'number'
+
+class OutputSchemaItem(OutputSchemaItemRequired, total=False):
+  description: str
+  required: bool
+
+
+def create_pydantic_model_from_schema(output_schema: Optional[List[Dict[str, Any]]]) -> Optional[type[BaseModel]]:
+  if not output_schema:
+    return None
+
+  field_definitions: Dict[str, Any] = {}
+  for item in output_schema:
+    type_mapping = {
+      'string': str,
+      'number': float,
+    }
+    field_type = type_mapping.get(item.get('type'), str)
+    description = item.get('description', '')
+    is_required = item.get('required', True)
+    if is_required:
+      field_definitions[item['name']] = (field_type, Field(description=description))
+    else:
+      field_definitions[item['name']] = (Optional[field_type], Field(default=None, description=description))
+
+  if field_definitions:
+    return create_model('DynamicOutputModel', **field_definitions)
+  return None
+
+
+async def main(session_id: str, cdp_url: str, task: str, output_schema_json: Optional[str] = None, otp_secret: Optional[str] = None):
+  llm = ChatOpenAI(
+    model="gpt-4.1",
+    api_key=os.getenv("OPENAI_API_KEY"),
+  )
+  folder_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), f'downloads_{session_id}')
+  
+  # Create folder if it doesn't exist
+  os.makedirs(folder_path, exist_ok=True)
+  
+  available_files = [os.path.join(folder_path, file) for file in os.listdir(folder_path)]
+  
+  # Set downloads_path to the local tools/files directory
+  browser_session = BrowserSession(
+    browser_profile=BrowserProfile(downloads_path=folder_path),
+    cdp_url=cdp_url
+  )
+
+  output_schema = None
+  if output_schema_json:
+    try:
+      output_schema = json.loads(output_schema_json)
+    except Exception:
+      output_schema = None
+
+  output_model = create_pydantic_model_from_schema(output_schema)
+  
+  # Build controller and register dynamic tools
+  controller = Controller(output_model=output_model) if output_model is not None else Controller()
+
+  # Dynamically add generate_otp action when OTP secret is provided
+
+  if otp_secret:
+    # Ensure pyotp is available when OTP is requested
+    try:
+      import pyotp  # type: ignore
+    except Exception as e:
+      raise RuntimeError("pyotp is required when otpSecret is provided. Install it with 'uv add pyotp'.") from e
+
+    @controller.registry.action("Generate a 6-digit TOTP code. Do not call any other tool at the same time.")
+    async def generate_otp() -> ActionResult:
+      try:
+        code = pyotp.TOTP(otp_secret).now()
+        print(f"Generated OTP: {code}")
+        return ActionResult(extracted_content=code)
+      except Exception as e:
+        print(f"Failed to generate OTP: {e}")
+        return ActionResult(extracted_content=f"Failed to generate OTP: {e}")
+
+  agent = Agent(
+    task=task,
+    llm=llm,
+    controller=controller,
+    available_file_paths=available_files,
+    browser_session=browser_session,
+  )
+  history = await agent.run()
+  final_result = history.final_result()
+  
+      # Parse result with output model if provided
+  parsed_result = None
+  if output_model and final_result:
+      try:
+          # Validate and parse the result using the Pydantic model
+          parsed_result = output_model.model_validate_json(final_result)
+          # Convert to dict for JSON serialization
+          parsed_result = parsed_result.model_dump()
+      except Exception as e:
+          print(f"Failed to parse result with output model: {e}")
+          # Fall back to raw result
+          parsed_result = final_result
+  else:
+      parsed_result = final_result
+  
+  print("___RESULT___")
+  if parsed_result:
+    print(json.dumps(parsed_result, indent=2))
+  else:
+    print(final_result)
+    
+if __name__ == '__main__':
+  # Prefer JSON payload via stdin; fallback to argv for backwards compatibility
+  payload_str = ''
+  try:
+    if not sys.stdin.isatty():
+      payload_str = sys.stdin.read().strip()
+  except Exception:
+    payload_str = ''
+
+  if payload_str:
+    try:
+      payload = json.loads(payload_str)
+    except Exception as e:
+      raise SystemExit(f"Failed to parse JSON payload from stdin: {e}")
+
+    session_id = payload.get('sessionId')
+    cdp_url = payload.get('cdpUrl')
+    task = payload.get('task')
+    output_schema = payload.get('outputSchema')
+    otp_secret = payload.get('otpSecret')
+
+    if not session_id or not cdp_url or not task:
+      raise SystemExit("Missing required fields in JSON payload: sessionId, cdpUrl, task")
+
+    output_schema_json = json.dumps(output_schema) if output_schema is not None else None
+    asyncio.run(main(session_id, cdp_url, task, output_schema_json, otp_secret))
+  else:
+    raise SystemExit("Usage: uv run executeBrowserTask.py; send a JSON payload via stdin")

package/src/browserTask/executeBrowserTask.ts

@@ -0,0 +1,253 @@
+import { spawn } from 'node:child_process';
+import { logger } from '../utils/logger';
+import { mindedConnection } from '../platform/mindedConnection';
+import path from 'path';
+import {
+  mindedConnectionSocketMessageType,
+  CreateBrowserSessionResponse,
+  InvokeBrowserTaskResponse,
+  CreateBrowserSessionRequest,
+  InvokeBrowserTaskRequest,
+  DestroyBrowserSessionRequest,
+  DestroyBrowserSessionResponse,
+} from '../platform/mindedConnectionTypes';
+import { kill, getOrStartLocalCDP, isLocalBrowserRunning } from './localBrowserTask';
+import { BrowserTaskMode, InvokeBrowserTaskOptions } from './types';
+import { isLocalOperatorSetup, validateLocalOperatorSetup } from '../cli/localOperatorSetup';
+
+// Map to track sessionId to instanceId for local browser sessions
+const localSessionInstances = new Map<string, string>();
+
+// Socket-based browser task functions
+export const createBrowserSession = async ({
+  sessionId,
+  proxy,
+  browserTaskMode,
+}: {
+  sessionId: string;
+  proxy?: string;
+  browserTaskMode: BrowserTaskMode;
+}): Promise<CreateBrowserSessionResponse> => {
+  logger.debug({ msg: 'Creating browser session via socket', proxy });
+
+  if (browserTaskMode === BrowserTaskMode.LOCAL) {
+    const { cdpUrl, instanceId } = await getOrStartLocalCDP({ headless: false });
+
+    // Store the mapping for cleanup later
+    localSessionInstances.set(sessionId, instanceId);
+
+    return {
+      sessionId,
+      cdpUrl,
+    };
+  }
+
+  const response = await mindedConnection.awaitEmit<CreateBrowserSessionRequest, CreateBrowserSessionResponse>(
+    mindedConnectionSocketMessageType.CREATE_BROWSER_SESSION,
+    {
+      type: mindedConnectionSocketMessageType.CREATE_BROWSER_SESSION,
+      proxy,
+      onPrem: browserTaskMode === BrowserTaskMode.ON_PREM,
+    },
+    60000, // 60 seconds timeout
+  );
+
+  if (response.error) {
+    logger.error({ msg: 'Failed to create browser session', error: response.error });
+    throw new Error(response.error);
+  }
+
+  logger.debug({
+    msg: 'Browser session created successfully',
+    sessionId: response.sessionId,
+    hasLiveUrl: !!response.liveViewUrl,
+  });
+
+  return response;
+};
+
+export const destroyBrowserSession = async ({
+  sessionId,
+  onPrem,
+  localRun,
+}: {
+  sessionId: string;
+  onPrem?: boolean;
+  localRun?: boolean;
+}): Promise<DestroyBrowserSessionResponse> => {
+  logger.debug({ msg: 'Destroying browser session via socket', sessionId, onPrem });
+
+  if (localRun || process.env.BROWSER_TASK_MODE === BrowserTaskMode.LOCAL) {
+    // Kill specific instance if we have the mapping
+    const instanceId = localSessionInstances.get(sessionId);
+    if (instanceId) {
+      await kill(instanceId);
+      localSessionInstances.delete(sessionId);
+    } else {
+      // Fallback to killing all if no specific instance found
+      logger.warn({ msg: 'No instance ID found for session, killing all instances', sessionId });
+      await kill();
+    }
+    return {
+      success: true,
+    };
+  }
+
+  const response = await mindedConnection.awaitEmit<DestroyBrowserSessionRequest, DestroyBrowserSessionResponse>(
+    mindedConnectionSocketMessageType.DESTROY_BROWSER_SESSION,
+    {
+      type: mindedConnectionSocketMessageType.DESTROY_BROWSER_SESSION,
+      sessionId,
+      onPrem,
+    },
+    30000,
+  );
+
+  if (response.error) {
+    logger.error({ msg: 'Failed to destroy browser session', error: response.error, sessionId });
+    throw new Error(response.error);
+  }
+
+  logger.debug({ msg: 'Browser session destroyed successfully', sessionId });
+  return response;
+};
+
+export const invokeBrowserTask = async (options: InvokeBrowserTaskOptions): Promise<InvokeBrowserTaskResponse> => {
+  try {
+    const { sessionId, cdpUrl, task, keepAlive, hooks, browserTaskMode, toolSchemas, outputSchema } = options;
+
+    if (browserTaskMode === BrowserTaskMode.LOCAL) {
+      validateLocalOperatorSetup();
+      const pythonScriptPath = path.resolve(__dirname, 'executeBrowserTask.py');
+
+      const args = ['run', pythonScriptPath];
+      logger.info({ message: 'Spawning Python process', args });
+
+      const child = spawn('uv', args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: isLocalOperatorSetup()
+          ? {
+              ...process.env,
+              VIRTUAL_ENV: path.join(process.cwd(), '.venv'),
+              PATH: `${path.join(process.cwd(), '.venv', 'bin')}:${process.env.PATH}`,
+            }
+          : process.env,
+      });
+
+      // Build payload to send over stdin
+      const payload = {
+        sessionId,
+        cdpUrl,
+        task,
+        outputSchema,
+        otpSecret: process.env.OTP_SECRET,
+      };
+
+      // Write JSON payload to stdin
+      child.stdin.write(JSON.stringify(payload));
+      child.stdin.end();
+
+      let stdoutBuffer = '';
+      let stderrBuffer = '';
+
+      child.stdout.on('data', (data) => {
+        const text = data.toString();
+        stdoutBuffer += text;
+        process.stdout.write(text);
+      });
+
+      child.stderr.on('data', (data) => {
+        const text = data.toString();
+        stderrBuffer += text;
+        process.stderr.write(text);
+      });
+
+      const interval = setInterval(() => {
+        // Check if chromium process stopped running
+        if (!isLocalBrowserRunning()) {
+          logger.error({ message: 'Local browser process stopped running, killing browser task' });
+          child.kill();
+          clearInterval(interval);
+        }
+      }, 1000);
+
+      // Automatically clear interval after 20 minutes to avoid memory leaks
+      setTimeout(() => {
+        clearInterval(interval);
+      }, 1200000); // 20 minutes
+
+      const exitCode: number = await new Promise((resolve, reject) => {
+        child.on('error', (err) => reject(err));
+        child.on('close', (code) => resolve(code ?? 1));
+      });
+
+      clearInterval(interval);
+
+      if (exitCode !== 0) {
+        logger.error({ message: 'Operator failed', exitCode, stderr: stderrBuffer });
+        throw new Error(`Local browser task failed with exit code ${exitCode}`);
+      }
+
+      logger.info({ message: 'Operator finished' });
+
+      let result = stdoutBuffer.split('___RESULT___')[1]?.trim() || stdoutBuffer;
+      if (outputSchema?.length) {
+        try {
+          result = JSON.parse(result);
+        } catch (error) {
+          logger.debug({ message: 'Failed to parse result', error });
+        }
+      }
+
+      return {
+        result,
+        steps: [],
+        recordings: [],
+      };
+    }
+
+    logger.debug({
+      msg: 'Invoking browser task via socket',
+      sessionId,
+      taskLength: task.length,
+      keepAlive,
+      hooksCount: hooks?.length || 0,
+      onPrem: browserTaskMode === BrowserTaskMode.ON_PREM,
+      outputSchemaFields: outputSchema?.length || 0,
+    });
+
+    const response = await mindedConnection.awaitEmit<InvokeBrowserTaskRequest, InvokeBrowserTaskResponse>(
+      mindedConnectionSocketMessageType.INVOKE_BROWSER_TASK,
+      {
+        type: mindedConnectionSocketMessageType.INVOKE_BROWSER_TASK,
+        cdpUrl,
+        task,
+        sessionId,
+        keepAlive,
+        hooks,
+        onPrem: browserTaskMode === BrowserTaskMode.ON_PREM,
+        toolSchemas,
+        outputSchema,
+      },
+      900000, // 15 minutes timeout
+    );
+
+    if (response.error) {
+      logger.error({ msg: 'Failed to invoke browser task', error: response.error });
+      throw new Error(response.error);
+    }
+
+    logger.debug({
+      msg: 'Browser task completed successfully',
+      sessionId,
+      hasResult: !!response.result,
+      stepCount: response.steps?.length || 0,
+      recordingCount: response.recordings?.length || 0,
+    });
+
+    return response;
+  } catch (err) {
+    logger.error({ message: 'Error invoking browser task', err });
+    throw err;
+  }
+};

package/src/browserTask/localBrowserTask.ts

@@ -0,0 +1,300 @@
+// getOrStartLocalCDP.ts
+import { spawn, ChildProcess } from 'child_process';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { chromium } from 'playwright';
+import { logger } from '../utils/logger';
+import { wait } from '../utils/wait';
+import * as net from 'net';
+
+interface BrowserInstance {
+  id: string;
+  cdpUrl: string;
+  proc: ChildProcess;
+  port: number;
+  profileDir?: string;
+}
+
+// Map to track multiple browser instances
+const browserInstances = new Map<string, BrowserInstance>();
+
+// Port range for Chrome instances
+const MIN_PORT = 9222;
+const MAX_PORT = 9322; // Allow up to 100 concurrent instances
+
+/**
+ * Find an available port in the specified range
+ */
+async function findAvailablePort(startPort: number = MIN_PORT, endPort: number = MAX_PORT): Promise<number> {
+  // First check if any ports are already in use by our instances
+  const usedPorts = new Set(Array.from(browserInstances.values()).map((instance) => instance.port));
+
+  for (let port = startPort; port <= endPort; port++) {
+    if (usedPorts.has(port)) {
+      continue;
+    }
+
+    const isAvailable = await checkPortAvailable(port);
+    if (isAvailable) {
+      return port;
+    }
+  }
+
+  throw new Error(`No available ports found in range ${startPort}-${endPort}`);
+}
+
+/**
+ * Check if a port is available
+ */
+function checkPortAvailable(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+
+    server.once('error', () => {
+      resolve(false);
+    });
+
+    server.once('listening', () => {
+      server.close();
+      resolve(true);
+    });
+
+    server.listen(port);
+  });
+}
+
+export type StartChromiumOptions = {
+  /** Headless by default. Set to false to see a window. */
+  headless?: boolean;
+  /** Extra CLI flags to pass to Chromium. */
+  extraArgs?: string[];
+  /** Provide your own user-data-dir. If omitted, a temp dir is created and later removable via `kill()`. */
+  userDataDir?: string;
+  /** Extra env vars. */
+  env?: NodeJS.ProcessEnv;
+  /** How long to wait for the DevTools port to come up (ms). Default: 10000 */
+  timeoutMs?: number;
+  /** Instance ID to reuse an existing browser instance. If not provided, a new instance will be created. */
+  instanceId?: string;
+  /** Preferred port to use. If not available, will find another available port. */
+  preferredPort?: number;
+};
+
+/**
+ * Launch Chromium with dynamic port allocation and return the CDP ws URL.
+ * Supports multiple concurrent instances.
+ * Works with Chrome/Chromium/Chrome for Testing.
+ */
+export async function getOrStartLocalCDP(opts: StartChromiumOptions): Promise<{ cdpUrl: string; instanceId: string }> {
+  // If instanceId is provided, try to reuse existing instance
+  if (opts.instanceId && browserInstances.has(opts.instanceId)) {
+    const instance = browserInstances.get(opts.instanceId)!;
+    return {
+      cdpUrl: instance.cdpUrl,
+      instanceId: instance.id,
+    };
+  }
+
+  // Generate a new instance ID if not provided
+  const instanceId = opts.instanceId || `browser-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+
+  const { env } = opts;
+
+  const executablePath = chromium.executablePath();
+
+  // Find an available port
+  const port = opts.preferredPort
+    ? (await checkPortAvailable(opts.preferredPort))
+      ? opts.preferredPort
+      : await findAvailablePort()
+    : await findAvailablePort();
+
+  logger.info({ message: `Starting Chrome instance on port ${port}`, instanceId });
+
+  const profileDir = path.join(__dirname, `profile-${instanceId}`);
+  await fs.mkdir(profileDir, { recursive: true });
+
+  const userDataDir = opts.userDataDir ?? profileDir;
+
+  const args = [
+    '--new-window',
+    `--user-data-dir=${userDataDir}`,
+    ...(process.env.HEADLESS === 'true' ? ['--headless'] : []),
+    '--disable-component-extensions-with-background-pages',
+    '--disable-background-networking',
+    '--disable-back-forward-cache',
+    '--disable-popup-blocking',
+    '--simulate-outdated-no-au="Tue, 31 Dec 2099 23:59:59 GMT"',
+    '--disable-renderer-backgrounding',
+    '--no-sandbox',
+    '--no-service-autorun',
+    '--disable-background-timer-throttling',
+    '--allow-legacy-extension-manifests',
+    '--allow-pre-commit-input',
+    '--log-level=2',
+    '--unsafely-disable-devtools-self-xss-warnings',
+    '--metrics-recording-only',
+    '--disable-window-activation',
+    '--disable-dev-shm-usage',
+    '--disable-backgrounding-occluded-windows',
+    '--disable-search-engine-choice-screen',
+    '--disable-print-preview',
+    '--disable-external-intent-requests',
+    '--disable-desktop-notifications',
+    '--disable-component-update',
+    '--generate-pdf-document-outline',
+    '--disable-focus-on-load',
+    '--disable-speech-api',
+    '--silent-debugger-extension-api',
+    '--suppress-message-center-popups',
+    '--disable-default-apps',
+    '--enable-network-information-downlink-max',
+    '--use-mock-keychain',
+    '--disable-ipc-flooding-protection',
+    '--safebrowsing-disable-auto-update',
+    '--install-autogenerated-theme=0,0,0',
+    '--disable-blink-features=AutomationControlled',
+    '--no-first-run',
+    '--extensions-on-chrome-urls',
+    '--ash-no-nudges',
+    '--no-pings',
+    '--test-type=gpu',
+    '--disable-client-side-phishing-detection',
+    '--password-store=basic',
+    '--enable-features=NetworkService,NetworkServiceInProcess',
+    '--disable-extensions-http-throttling',
+    '--disable-speech-synthesis-api',
+    '--no-default-browser-check',
+    '--disable-hang-monitor',
+    '--hide-crash-restore-bubble',
+    '--disable-domain-reliability',
+    '--export-tagged-pdf',
+    '--disable-sync',
+    '--disable-features=AcceptCHFrame,AutoExpandDetailsElement,AvoidUnnecessaryBeforeUnloadCheckSync,CertificateTransparencyComponentUpdater,DestroyProfileOnBrowserClose,DialMediaRouteProvider,ExtensionManifestV2Disabled,GlobalMediaControls,HttpsUpgrades,ImprovedCookieControls,LazyFrameLoading,LensOverlay,MediaRouter,PaintHolding,ThirdPartyStoragePartitioning,Translate,AutomationControlled,BackForwardCache,OptimizationHints,ProcessPerSiteUpToMainFrameThreshold,InterestFeedContentSuggestions,CalculateNativeWinOcclusion,HeavyAdPrivacyMitigations,PrivacySandboxSettings4,AutofillServerCommunication,CrashReporting,OverscrollHistoryNavigation,InfiniteSessionRestore,ExtensionDisableUnsupportedDeveloper',
+    '--disable-prompt-on-repost',
+    '--disable-infobars',
+    '--disable-datasaver-prompt',
+    '--noerrdialogs',
+    '--disable-breakpad',
+    '--disable-field-trial-config',
+    '--window-size=1920,1080',
+    '--window-position=0,0',
+    '--enable-extensions',
+    '--disable-extensions-file-access-check',
+    '--enable-extension-activity-logging',
+    `--remote-debugging-port=${port}`,
+    '--remote-debugging-address=0.0.0.0',
+    'about:blank',
+  ];
+
+  const proc = spawn(executablePath, args, {
+    stdio: ['ignore', 'ignore', 'pipe'], // stderr is useful for debugging
+    env: { ...process.env, ...env },
+  });
+
+  proc.on('error', (error) => {
+    logger.error({ message: 'Chromium error', error });
+  });
+
+  proc.on('exit', (code, signal) => {
+    logger.error({ message: 'Chromium exited', code, signal, instanceId, port });
+    // Clean up the instance from our map
+    browserInstances.delete(instanceId);
+  });
+
+  await waitForCdpEndpoint(port, 30);
+
+  const cdpUrl = `http://127.0.0.1:${port}`;
+
+  const instance: BrowserInstance = {
+    id: instanceId,
+    cdpUrl,
+    proc,
+    port,
+    profileDir: userDataDir === profileDir ? profileDir : undefined,
+  };
+
+  browserInstances.set(instanceId, instance);
+
+  logger.info({ message: 'Local browser task started', cdpUrl, instanceId, port, totalInstances: browserInstances.size });
+
+  return { cdpUrl, instanceId };
+}
+
+// Legacy HTTP polling helpers removed in favor of waitForCdpEndpoint
+
+async function waitForCdpEndpoint(port: number, maxAttempts: number): Promise<void> {
+  logger.info({ message: `Waiting for CDP endpoint on port ${port}...` });
+  for (let attemptIndex = 0; attemptIndex < maxAttempts; attemptIndex++) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/json/version`);
+      if (response.ok) {
+        const version = await response.json();
+        logger.info({ message: `CDP endpoint ready on port ${port}`, version: version['Browser'] });
+        return;
+      }
+    } catch (error) {
+      if (attemptIndex % 5 === 0) {
+        logger.debug({ message: `CDP endpoint not ready yet, attempt ${attemptIndex + 1}/${maxAttempts}`, error });
+      }
+    }
+    await wait(1000);
+  }
+  throw new Error(`CDP endpoint not available on port ${port} after ${maxAttempts} attempts`);
+}
+
+export function isLocalBrowserRunning(instanceId?: string): boolean {
+  if (instanceId) {
+    return browserInstances.has(instanceId);
+  }
+  return browserInstances.size > 0;
+}
+
+/**
+ * Get all running browser instances
+ */
+export function getAllBrowserInstances(): Map<string, BrowserInstance> {
+  return new Map(browserInstances);
+}
+
+/**
+ * Get a specific browser instance
+ */
+export function getBrowserInstance(instanceId: string): BrowserInstance | undefined {
+  return browserInstances.get(instanceId);
+}
+
+/**
+ * Kill a specific browser instance or all instances
+ * @param instanceId - Optional instance ID to kill. If not provided, kills all instances.
+ */
+export async function kill(instanceId?: string) {
+  if (instanceId) {
+    // Kill specific instance
+    const instance = browserInstances.get(instanceId);
+    if (instance) {
+      logger.info({ message: 'Killing browser instance', instanceId, port: instance.port });
+      instance.proc.kill('SIGTERM');
+      await wait(300);
+      if (!instance.proc.killed) {
+        instance.proc.kill('SIGKILL');
+      }
+
+      // Clean up profile directory if it was auto-generated
+      if (instance.profileDir) {
+        try {
+          await fs.rm(instance.profileDir, { recursive: true, force: true });
+        } catch (error) {
+          logger.warn({ message: 'Failed to clean up profile directory', instanceId, error });
+        }
+      }
+
+      browserInstances.delete(instanceId);
+    }
+  } else {
+    // Kill all instances
+    logger.info({ message: 'Killing all browser instances', count: browserInstances.size });
+    const killPromises = Array.from(browserInstances.keys()).map((id) => kill(id));
+    await Promise.all(killPromises);
+  }
+}