@minded-ai/mindedjs 3.1.45 → 3.1.48

package/src/platform/config.ts

@@ -3,6 +3,7 @@ import { config } from 'dotenv';
 import { Environment } from '../types/Platform.types';
 import { BrowserTaskMode } from '../browserTask/types';
 import { logger } from '../utils/logger';
+import { MindedProxyMode, ProxyConfig, ProxyProvider } from '../types/Tools.types';
 const path = resolve(__dirname, '../../.env');
 config({ path });
 
@@ -18,6 +19,7 @@ type MindedConfig = {
   elevenLabsKey: string | null;
   elevenLabsAgentId: string | null;
   browserTaskMode: BrowserTaskMode;
+  proxyConfig: ProxyConfig | null;
   isDeprioritizedSocket: boolean;
 };
 
@@ -37,8 +39,73 @@ const parseBrowserTaskMode = (value: string | undefined): BrowserTaskMode => {
   return BrowserTaskMode.CLOUD;
 };
 
+const parseProxyConfig = (): ProxyConfig | null => {
+  const provider = process.env.BROWSER_PROXY_PROVIDER?.trim();
+  if (!provider) {
+    return null;
+  }
+
+  if (provider === ProxyProvider.MINDED) {
+    const mode = process.env.BROWSER_PROXY_MODE?.trim();
+    if (mode === MindedProxyMode.TRUSTED_IP) {
+      return {
+        provider: ProxyProvider.MINDED,
+        mode: MindedProxyMode.TRUSTED_IP,
+      };
+    }
+    if (mode === MindedProxyMode.REGION) {
+      const countryCode = process.env.BROWSER_PROXY_COUNTRY_CODE?.trim();
+      if (!countryCode) {
+        logger.warn({
+          message: 'BROWSER_PROXY_COUNTRY_CODE is required when BROWSER_PROXY_MODE is region; ignoring proxy config',
+        });
+        return null;
+      }
+      return {
+        provider: ProxyProvider.MINDED,
+        mode: MindedProxyMode.REGION,
+        countryCode,
+      };
+    }
+    logger.warn({
+      message: 'Invalid BROWSER_PROXY_MODE provided; ignoring proxy config',
+      provided: mode,
+      allowed: [MindedProxyMode.TRUSTED_IP, MindedProxyMode.REGION],
+    });
+    return null;
+  }
+
+  if (provider === ProxyProvider.CUSTOM) {
+    const server = process.env.BROWSER_PROXY_SERVER?.trim();
+    if (!server) {
+      logger.warn({
+        message: 'BROWSER_PROXY_SERVER is required when BROWSER_PROXY_PROVIDER is custom; ignoring proxy config',
+      });
+      return null;
+    }
+    const username = process.env.BROWSER_PROXY_USERNAME?.trim();
+    const password = process.env.BROWSER_PROXY_PASSWORD?.trim();
+    return {
+      provider: ProxyProvider.CUSTOM,
+      server,
+      ...(username ? { username } : {}),
+      ...(password ? { password } : {}),
+    };
+  }
+
+  logger.warn({
+    message: 'Invalid BROWSER_PROXY_PROVIDER provided; ignoring proxy config',
+    provided: provider,
+    allowed: [ProxyProvider.MINDED, ProxyProvider.CUSTOM],
+  });
+  return null;
+};
+
 export const getConfig = (): MindedConfig => {
   const environment = (process.env.NODE_ENV as Environment) || Environment.DEVELOPMENT;
+  const browserTaskMode = parseBrowserTaskMode(process.env.BROWSER_TASK_MODE);
+  const proxyConfig = parseProxyConfig();
+
   switch (environment) {
     case Environment.TEST:
       return {
@@ -52,7 +119,8 @@ export const getConfig = (): MindedConfig => {
         dashboardConnected: false,
         elevenLabsKey: process.env.ELEVEN_LABS_API_KEY || null,
         elevenLabsAgentId: process.env.ELEVEN_LABS_AGENT_ID || null,
-        browserTaskMode: parseBrowserTaskMode(process.env.BROWSER_TASK_MODE),
+        browserTaskMode,
+        proxyConfig,
         isDeprioritizedSocket: process.env.IS_DEPRIORITIZED_SOCKET === 'true',
       };
     case Environment.DEVELOPMENT:
@@ -67,7 +135,8 @@ export const getConfig = (): MindedConfig => {
         elevenLabsKey: process.env.ELEVEN_LABS_API_KEY || null,
         dashboardConnected: true,
         elevenLabsAgentId: process.env.ELEVEN_LABS_AGENT_ID || 'agent_01jye194psezr909nwec27m2t9',
-        browserTaskMode: parseBrowserTaskMode(process.env.BROWSER_TASK_MODE),
+        browserTaskMode,
+        proxyConfig,
         isDeprioritizedSocket: process.env.IS_DEPRIORITIZED_SOCKET === 'true',
       };
     case Environment.STAGING:
@@ -82,7 +151,8 @@ export const getConfig = (): MindedConfig => {
         elevenLabsKey: process.env.ELEVEN_LABS_API_KEY || null,
         dashboardConnected: false,
         elevenLabsAgentId: process.env.ELEVEN_LABS_AGENT_ID || 'agent_01jye1ajkaf17axpcxg220qwcm',
-        browserTaskMode: parseBrowserTaskMode(process.env.BROWSER_TASK_MODE),
+        browserTaskMode,
+        proxyConfig,
         isDeprioritizedSocket: process.env.IS_DEPRIORITIZED_SOCKET === 'true',
       };
     case Environment.PRODUCTION:
@@ -97,7 +167,8 @@ export const getConfig = (): MindedConfig => {
         elevenLabsKey: process.env.ELEVEN_LABS_API_KEY || null,
         dashboardConnected: false,
         elevenLabsAgentId: process.env.ELEVEN_LABS_AGENT_ID || 'agent_01jye1ajkaf17axpcxg220qwcm',
-        browserTaskMode: parseBrowserTaskMode(process.env.BROWSER_TASK_MODE),
+        browserTaskMode,
+        proxyConfig,
         isDeprioritizedSocket: process.env.IS_DEPRIORITIZED_SOCKET === 'true',
       };
   }

package/src/platform/toolExecutor.ts

@@ -2,7 +2,7 @@ import { Tool } from '../types/Tools.types';
 import { Agent } from '../agent';
 import { logger } from '../utils/logger';
 import { withBrowserSession } from '../toolsLibrary/withBrowserSession';
-import { getConfig } from './config';
+import { resolveRpaBrowserSessionOptions } from '../browserTask/resolveRpaBrowserSessionOptions';
 
 export interface ToolExecutionRequest {
   toolName: string;
@@ -86,9 +86,10 @@ export class ToolExecutor {
 
       // Check if this is an RPA tool
       if (tool.type === 'rpa') {
-        const configBrowserTaskMode = getConfig().browserTaskMode;
-        // Use tool's browserTaskMode if provided, otherwise fall back to config
-        const browserTaskMode = tool.browserTaskMode ?? configBrowserTaskMode;
+        const { browserTaskMode, proxyConfig } = resolveRpaBrowserSessionOptions({
+          toolBrowserTaskMode: tool.browserTaskMode,
+          toolProxyConfig: tool.proxyConfig,
+        });
 
         // Wrap with browser session and screenshot capture
         const { result, breakpointHit, breakpointInfo } = await withBrowserSession(
@@ -96,7 +97,7 @@ export class ToolExecutor {
             sessionId,
             browserTaskMode,
             toolCallId: requestId, // Use requestId as toolCallId for tracking
-            proxyConfig: tool.proxyConfig,
+            proxyConfig,
             toolName,
             persistSession: tool.persistSession,
           },

package/src/toolsLibrary/browserSessionPersistence.ts

@@ -3,6 +3,7 @@ import { logger } from '../utils/logger';
 import { saveRecord, getRecords } from './storage';
 
 const BROWSER_SESSION_KEY = 'browser-session';
+const STORAGE_OPERATION_TIMEOUT_MS = 3000;
 
 interface Cookie {
   name: string;
@@ -20,11 +21,34 @@ interface LocalStorageEntry {
   data: Record<string, string>;
 }
 
+const withTimeout = async <T>(promise: Promise<T>, timeoutMs: number, operation: string): Promise<T> => {
+  let timeout: NodeJS.Timeout | null = null;
+
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(() => {
+          reject(new Error(`${operation} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+};
+
 /**
  * Extract localStorage from the current page
  */
 const extractLocalStorageFromPage = async (page: Page): Promise<Record<string, string>> => {
-  return await page.evaluate(() => Object.fromEntries(Object.entries(localStorage)));
+  return await withTimeout(
+    page.evaluate(() => Object.fromEntries(Object.entries(localStorage))),
+    STORAGE_OPERATION_TIMEOUT_MS,
+    'Extract localStorage from current page',
+  );
 };
 
 /**
@@ -64,7 +88,11 @@ export const saveSessionDataViaSocket = async (
   sessionId: string,
 ): Promise<void> => {
   try {
-    const cookies = await context.cookies();
+    const cookies = await withTimeout(
+      context.cookies(),
+      STORAGE_OPERATION_TIMEOUT_MS,
+      'Extract browser cookies',
+    );
     const data: Record<string, unknown> = {};
 
     if (cookies && cookies.length > 0) {
@@ -74,10 +102,18 @@ export const saveSessionDataViaSocket = async (
     // Extract localStorage for ALL origins using CDP
     let client;
     try {
-      client = await context.newCDPSession(page);
+      client = await withTimeout(
+        context.newCDPSession(page),
+        STORAGE_OPERATION_TIMEOUT_MS,
+        'Create CDP session for browser session persistence',
+      );
 
       // Enable Target domain to track all frames and their origins
-      await client.send('Target.setDiscoverTargets', { discover: true });
+      await withTimeout(
+        client.send('Target.setDiscoverTargets', { discover: true }),
+        STORAGE_OPERATION_TIMEOUT_MS,
+        'Enable CDP target discovery',
+      );
 
       // Get all targets (frames, workers, etc.)
       type TargetInfo = {
@@ -88,7 +124,11 @@ export const saveSessionDataViaSocket = async (
         attached: boolean;
       };
 
-      const response = await client.send('Target.getTargets');
+      const response = await withTimeout(
+        client.send('Target.getTargets'),
+        STORAGE_OPERATION_TIMEOUT_MS,
+        'Get CDP targets for localStorage persistence',
+      );
       const targetInfos = (response as { targetInfos: TargetInfo[] }).targetInfos;
 
       // Extract unique origins from all page-type targets
@@ -121,12 +161,16 @@ export const saveSessionDataViaSocket = async (
             entries: Array<[string, string]>;
           };
 
-          const storageResponse = await client!.send('DOMStorage.getDOMStorageItems', {
-            storageId: {
-              securityOrigin: origin,
-              isLocalStorage: true,
-            },
-          });
+          const storageResponse = await withTimeout(
+            client!.send('DOMStorage.getDOMStorageItems', {
+              storageId: {
+                securityOrigin: origin,
+                isLocalStorage: true,
+              },
+            }),
+            STORAGE_OPERATION_TIMEOUT_MS,
+            `Extract localStorage for origin ${origin}`,
+          );
           const { entries } = storageResponse as DOMStorageResponse;
 
           if (entries && entries.length > 0) {
@@ -178,7 +222,11 @@ export const saveSessionDataViaSocket = async (
       }
     } finally {
       if (client) {
-        await client.detach().catch(() => { });
+        await withTimeout(
+          client.detach(),
+          STORAGE_OPERATION_TIMEOUT_MS,
+          'Detach CDP session after browser session persistence',
+        ).catch(() => { });
       }
     }