@minded-ai/mindedjs 3.1.21 → 3.1.22

package/src/browserTask/executeBrowserTask.ts

@@ -17,7 +17,6 @@ import { BrowserTaskMode, InvokeBrowserTaskOptions } from './types';
 import { isLocalOperatorSetup, validateLocalOperatorSetup } from '../cli/localOperatorSetup';
 import { getConfig } from '../platform/config';
 import CDP from 'chrome-remote-interface';
-import { CookieStore } from './CookieStore';
 import { ProxyType } from '../types/Tools.types';
 
 // Map to track sessionId to instanceId for local browser sessions
@@ -26,9 +25,6 @@ const localSessionInstances = new Map<string, string>();
 // Map to track CDP clients for cookie management
 const cdpClients = new Map<string, CDP.Client>();
 
-// Initialize cookie store
-const cookieStore = new CookieStore(path.join(process.cwd(), 'local_storage', 'cookies'));
-
 // Helper function to extract port from CDP URL
 const extractPortFromCdpUrl = (cdpUrl: string): number | null => {
   try {
@@ -39,61 +35,6 @@ const extractPortFromCdpUrl = (cdpUrl: string): number | null => {
   }
 };
 
-// Helper function to load cookies for a session
-const loadCookiesForSession = async (sessionId: string): Promise<void> => {
-  // Check if cookies should be disabled
-  const noCookies = process.env.MINDED_NO_COOKIES === 'true';
-  if (noCookies) {
-    logger.info({ message: '[Browser] Cookies disabled via cookies=false flag', sessionId });
-    return;
-  }
-
-  const stored = await cookieStore.load();
-  if (!stored || stored.length === 0) {
-    logger.info({ message: '[Browser] No stored cookies to load', sessionId });
-    return;
-  }
-  const cdp = cdpClients.get(sessionId);
-  if (!cdp) {
-    logger.warn({ message: '[Browser] No CDP client found for session', sessionId });
-    return;
-  }
-
-  try {
-    await cdp.Network.setCookies({ cookies: stored });
-    logger.info({ message: '[Browser] Loaded cookies into browser session', sessionId, count: stored.length });
-  } catch (error) {
-    logger.warn({ message: '[Browser] Failed to set cookies via CDP', sessionId, error });
-  }
-};
-
-// Helper function to save cookies for a session
-const saveCookiesForSession = async (sessionId: string): Promise<void> => {
-  // Check if cookies should be disabled
-  const noCookies = process.env.MINDED_NO_COOKIES === 'true';
-  if (noCookies) {
-    return;
-  }
-
-  try {
-    const cdp = cdpClients.get(sessionId);
-    if (!cdp) {
-      logger.warn({ message: '[Browser] No CDP client found for session', sessionId });
-      return;
-    }
-
-    const result = await cdp.Network.getAllCookies();
-    if (result) {
-      await cookieStore.save(result.cookies);
-      logger.info({ message: '[Browser] Saved cookies from browser session', sessionId, count: result.cookies.length });
-    } else {
-      logger.warn({ message: '[Browser] No cookies found in browser session', sessionId });
-    }
-  } catch (error) {
-    logger.warn({ message: '[Browser] Failed to get/save cookies from session', sessionId, error: JSON.stringify(error) });
-  }
-};
-
 // Helper function to cleanup CDP client
 const cleanupCdpClient = async (sessionId: string): Promise<void> => {
   const cdp = cdpClients.get(sessionId);
@@ -144,13 +85,6 @@ export const createBrowserSession = async ({
       logger.info({ message: '[Browser] Created CDP client for session', sessionId, port });
     }
 
-    // Load cookies for this session (best-effort)
-    try {
-      await loadCookiesForSession(sessionId);
-    } catch (error) {
-      logger.warn({ message: '[Browser] Failed to load cookies for session', sessionId, error });
-    }
-
     return {
       sessionId,
       cdpUrl,
@@ -213,6 +147,7 @@ export const destroyBrowserSession = async ({
     };
   }
 
+  // Destroy browser sessions via socket for both cloud and on-prem
   const response = await mindedConnection.awaitEmit<DestroyBrowserSessionRequest, DestroyBrowserSessionResponse>(
     mindedConnectionSocketMessageType.DESTROY_BROWSER_SESSION,
     {
@@ -345,13 +280,6 @@ export const invokeBrowserTask = async (options: InvokeBrowserTaskOptions): Prom
           }
         }
 
-        // Save cookies after task completes (best-effort)
-        try {
-          await saveCookiesForSession(sessionId);
-        } catch (error) {
-          logger.warn({ message: '[Browser] Failed to save cookies after task completion', sessionId, error });
-        }
-
         return {
           result,
           steps: [],

package/src/nodes/addPromptNode.ts

@@ -84,6 +84,7 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
                 browserTaskMode,
                 toolCallId,
                 toolName: tool.name,
+                persistSession: tool.persistSession,
               },
               async (page) => {
                 // Pass page directly to RPA tool execution

package/src/nodes/addToolRunNode.ts

@@ -53,6 +53,7 @@ export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeNam
               proxyUser: matchedTool.proxyUser,
               proxyPass: matchedTool.proxyPass,
               toolName: matchedTool.name,
+              persistSession: matchedTool.persistSession,
             },
             async (page) => {
               // Pass page directly to RPA tool execution

package/src/platform/toolExecutor.ts

@@ -99,6 +99,7 @@ export class ToolExecutor {
             proxyCountryCode: tool.proxyCountryCode,
             proxyType: tool.proxyType,
             toolName,
+            persistSession: tool.persistSession,
           },
           async (page) => {
             // Pass page directly to RPA tool execution

package/src/toolsLibrary/browserSessionPersistence.ts

@@ -0,0 +1,203 @@
+import { BrowserContext, Page } from 'playwright';
+import { logger } from '../utils/logger';
+import { saveRecord, getRecords } from './storage';
+
+const BROWSER_SESSION_KEY = 'browser-session';
+
+interface Cookie {
+  name: string;
+  value: string;
+  domain?: string;
+  path?: string;
+  expires?: number;
+  httpOnly?: boolean;
+  secure?: boolean;
+  sameSite?: 'Strict' | 'Lax' | 'None';
+}
+
+interface LocalStorageEntry {
+  url: string;
+  data: Record<string, string>;
+}
+
+/**
+ * Extract localStorage from the current page
+ */
+const extractLocalStorageFromPage = async (page: Page): Promise<Record<string, string>> => {
+  return await page.evaluate(() => Object.fromEntries(Object.entries(localStorage)));
+};
+
+/**
+ * Fetch both cookies and localStorage
+ */
+export const fetchSessionDataViaSocket = async (): Promise<{
+  cookies: Cookie[] | null;
+  localStorage: LocalStorageEntry[] | null;
+}> => {
+  try {
+    const records = await getRecords({
+      filters: { key: BROWSER_SESSION_KEY },
+    });
+
+    if (records.length === 0) {
+      return { cookies: null, localStorage: null };
+    }
+
+    // Take the last (most recent) record
+    const latestRecord = records[records.length - 1];
+    const cookies = latestRecord.data?.cookies || null;
+    const localStorage = latestRecord.data?.localStorage || null;
+
+    return { cookies, localStorage };
+  } catch (error) {
+    logger.warn({ message: 'Failed to fetch session data', error });
+    return { cookies: null, localStorage: null };
+  }
+};
+
+/**
+ * Save both cookies and localStorage for ALL origins
+ */
+export const saveSessionDataViaSocket = async (
+  context: BrowserContext,
+  page: Page,
+  sessionId: string,
+): Promise<void> => {
+  try {
+    const cookies = await context.cookies();
+    const data: Record<string, unknown> = {};
+
+    if (cookies && cookies.length > 0) {
+      data.cookies = cookies;
+    }
+
+    // Extract localStorage for ALL origins using CDP
+    let client;
+    try {
+      client = await context.newCDPSession(page);
+
+      // Enable Target domain to track all frames and their origins
+      await client.send('Target.setDiscoverTargets', { discover: true });
+
+      // Get all targets (frames, workers, etc.)
+      type TargetInfo = {
+        targetId: string;
+        type: string;
+        title: string;
+        url: string;
+        attached: boolean;
+      };
+
+      const response = await client.send('Target.getTargets');
+      const targetInfos = (response as { targetInfos: TargetInfo[] }).targetInfos;
+
+      // Extract unique origins from all page-type targets
+      const origins = new Set<string>();
+      for (const target of targetInfos || []) {
+        if (target.type === 'page' || target.type === 'iframe') {
+          try {
+            const url = new URL(target.url);
+            if (url.protocol === 'http:' || url.protocol === 'https:') {
+              origins.add(url.origin);
+            }
+          } catch {
+            // Ignore invalid URLs
+          }
+        }
+      }
+
+      // Also add the current page origin
+      try {
+        const currentOrigin = new URL(page.url()).origin;
+        origins.add(currentOrigin);
+      } catch {
+        // Ignore if current URL is invalid
+      }
+
+      // Extract localStorage from all origins in parallel
+      const extractionPromises = Array.from(origins).map(async (origin) => {
+        try {
+          type DOMStorageResponse = {
+            entries: Array<[string, string]>;
+          };
+
+          const storageResponse = await client!.send('DOMStorage.getDOMStorageItems', {
+            storageId: {
+              securityOrigin: origin,
+              isLocalStorage: true,
+            },
+          });
+          const { entries } = storageResponse as DOMStorageResponse;
+
+          if (entries && entries.length > 0) {
+            const data = Object.fromEntries(entries);
+
+            // Check payload size to prevent WebSocket errors (10MB limit as safety margin)
+            const dataSize = JSON.stringify(data).length;
+            if (dataSize > 10 * 1024 * 1024) {
+              logger.warn({
+                message: 'localStorage data too large, skipping origin',
+                origin,
+                sizeMB: (dataSize / 1024 / 1024).toFixed(2)
+              });
+              return null;
+            }
+
+            return {
+              url: origin,
+              data,
+            };
+          }
+        } catch (err) {
+          logger.warn({ message: 'Failed to extract localStorage for origin', origin, error: err });
+        }
+        return null;
+      });
+
+      const results = await Promise.all(extractionPromises);
+      const localStorageByOrigin = results.filter(Boolean) as LocalStorageEntry[];
+
+      if (localStorageByOrigin.length > 0) {
+        data.localStorage = localStorageByOrigin;
+      }
+    } catch (err) {
+      // Fallback: If CDP approach fails, use current page only
+      logger.warn({ message: 'Failed to extract localStorage via CDP, falling back to current page', error: err });
+      try {
+        const currentUrl = page.url();
+        const localStorageData = await extractLocalStorageFromPage(page);
+
+        if (Object.keys(localStorageData).length > 0) {
+          data.localStorage = [{
+            url: currentUrl,
+            data: localStorageData
+          }];
+        }
+      } catch (fallbackErr) {
+        logger.warn({ message: 'Failed to extract localStorage via fallback method', error: fallbackErr });
+      }
+    } finally {
+      if (client) {
+        await client.detach().catch(() => {});
+      }
+    }
+
+    if (Object.keys(data).length === 0) {
+      return;
+    }
+
+    // Add key to data for filtering
+    data.key = BROWSER_SESSION_KEY;
+
+    // Save with the actual sessionId, not a constant key
+    // TTL: 10 days (in seconds)
+    const TTL_10_DAYS = 10 * 24 * 60 * 60;
+    try {
+      await saveRecord(sessionId, data, TTL_10_DAYS);
+    } catch (error) {
+      logger.warn({ message: 'Failed to save session data', sessionId, error });
+    }
+  } catch (error) {
+    logger.warn({ message: 'Failed to save session data', sessionId, error });
+  }
+};

package/src/toolsLibrary/withBrowserSession.ts

@@ -4,13 +4,10 @@ import { createBrowserSession, destroyBrowserSession } from '../browserTask/exec
 import { logger } from '../utils/logger';
 import * as fs from 'fs';
 import * as path from 'path';
-import { CookieStore } from '../browserTask/CookieStore';
 import { awaitEmit, emit } from '../platform/mindedConnection';
 import { mindedConnectionSocketMessageType } from '../platform/mindedConnectionTypes';
 import { ProxyType } from '../types/Tools.types';
-
-// Initialize cookie store
-const cookieStore = new CookieStore(path.join(process.cwd(), 'local_storage', 'cookies'));
+import { fetchSessionDataViaSocket, saveSessionDataViaSocket } from './browserSessionPersistence';
 
 /**
  * Strips unnecessary content from HTML to reduce file size
@@ -85,7 +82,6 @@ class ScreenshotCapture {
           error,
         });
       });
-
     } catch (error) {
       logger.warn({
         message: 'Failed to capture screenshot',
@@ -141,7 +137,7 @@ class LogsCapture {
     try {
       const timestamp = new Date().toISOString();
 
-      // Send logs to backend via socket (upload all logs accumulated so far)
+      // Send full log history to backend - backend overwrites the file on each upload
       await awaitEmit(mindedConnectionSocketMessageType.RPA_LOGS_UPLOAD, {
         type: mindedConnectionSocketMessageType.RPA_LOGS_UPLOAD,
         sessionId: this.sessionId,
@@ -216,13 +212,20 @@ const createProxyLocator = (
 /**
  * Create a proxy page that intercepts actions and captures screenshots and logs
  */
-const createProxyPage = (
-  page: Page,
-  screenshotCapture: ScreenshotCapture,
-  logsCapture: LogsCapture,
-): Page => {
+const createProxyPage = (page: Page, screenshotCapture: ScreenshotCapture, logsCapture: LogsCapture): Page => {
   // List of methods to intercept for screenshot capture and logging
-  const methodsToIntercept = ['click', 'fill', 'type', 'goto', 'selectOption', 'check', 'uncheck', 'setInputFiles', 'waitForTimeout', 'evaluate'];
+  const methodsToIntercept = [
+    'click',
+    'fill',
+    'type',
+    'goto',
+    'selectOption',
+    'check',
+    'uncheck',
+    'setInputFiles',
+    'waitForTimeout',
+    'evaluate',
+  ];
   // Methods that return locators and need special handling
   const locatorMethods = ['locator'];
 
@@ -323,37 +326,6 @@ const formatLocatorActionLog = (action: string, selector: string | undefined, ar
   }
 };
 
-// Helper function to load cookies for a session
-const loadCookiesForSession = async (context: BrowserContext, sessionId: string): Promise<void> => {
-  const stored = await cookieStore.load();
-  if (!stored || stored.length === 0) {
-    logger.info({ message: 'No stored cookies to load', sessionId });
-    return;
-  }
-
-  try {
-    await context.addCookies(stored);
-    logger.info({ message: 'Loaded cookies into browser session', sessionId, count: stored.length });
-  } catch (error) {
-    logger.warn({ message: 'Failed to add cookies to context', sessionId, error });
-  }
-};
-
-// Helper function to save cookies for a session
-const saveCookiesForSession = async (context: BrowserContext, sessionId: string): Promise<void> => {
-  try {
-    const cookies = await context.cookies();
-    if (cookies && cookies.length > 0) {
-      await cookieStore.save(cookies);
-      logger.info({ message: 'Saved cookies from browser session', sessionId, count: cookies.length });
-    } else {
-      logger.info({ message: 'No cookies found in browser session', sessionId });
-    }
-  } catch (error) {
-    logger.warn({ message: 'Failed to get/save cookies from session', sessionId, error: JSON.stringify(error) });
-  }
-};
-
 export const withBrowserSession = async <T>(
   {
     sessionId,
@@ -365,6 +337,7 @@ export const withBrowserSession = async <T>(
     proxyUser,
     proxyPass,
     toolName,
+    persistSession = true,
   }: {
     sessionId: string;
     browserTaskMode: BrowserTaskMode;
@@ -375,10 +348,19 @@ export const withBrowserSession = async <T>(
     proxyUser?: string;
     proxyPass?: string;
     toolName: string;
+    persistSession?: boolean;
   },
   callback: (page: Page) => Promise<T>,
 ): Promise<{ result: T }> => {
-  const { cdpUrl } = await createBrowserSession({ sessionId, browserTaskMode, proxyCountryCode, proxyType, proxyServer, proxyUser, proxyPass });
+  const { cdpUrl } = await createBrowserSession({
+    sessionId,
+    browserTaskMode,
+    proxyCountryCode,
+    proxyType,
+    proxyServer,
+    proxyUser,
+    proxyPass,
+  });
   if (!cdpUrl) {
     throw new Error('CDP URL was not provided by the browser session.');
   }
@@ -409,16 +391,52 @@ export const withBrowserSession = async <T>(
   const logsCapture = new LogsCapture(sessionId, toolCallId);
   page = createProxyPage(page, screenshotCapture, logsCapture);
 
-  // Load cookies for this session (only for local mode, best-effort)
-  const noCookies = process.env.MINDED_NO_COOKIES === 'true';
-  if (browserTaskMode === BrowserTaskMode.LOCAL && !noCookies) {
+  // Load session data (cookies + localStorage) once at startup (if persistence is enabled)
+  if (persistSession) {
     try {
-      await loadCookiesForSession(context, sessionId);
+      const { cookies, localStorage: localStorageEntries } = await fetchSessionDataViaSocket();
+
+      // Load cookies into browser context
+      if (cookies && cookies.length > 0) {
+        await context.addCookies(cookies);
+        logger.info({ message: 'Loaded cookies into browser session', sessionId, count: cookies.length });
+      }
+
+      // Inject localStorage for ALL origins using addInitScript
+      // This runs on EVERY page load, but only sets items that don't already exist
+      // This prevents overwriting user changes during the session while restoring stored data
+      if (localStorageEntries && localStorageEntries.length > 0) {
+        const localStorageByOrigin = localStorageEntries.reduce(
+          (acc, entry) => {
+            try {
+              const origin = new URL(entry.url).origin;
+              acc[origin] = entry.data;
+            } catch (error) {
+              logger.warn({ message: 'Failed to parse origin for localStorage', url: entry.url, error });
+            }
+            return acc;
+          },
+          {} as Record<string, Record<string, string>>,
+        );
+
+        await context.addInitScript((storageData: Record<string, Record<string, string>>) => {
+          const currentOrigin = window.location.origin;
+          const dataForOrigin = storageData[currentOrigin];
+
+          if (dataForOrigin) {
+            // Only set items that don't already exist (non-destructive merge)
+            // This preserves any changes made by the user during the current session
+            for (const [key, value] of Object.entries(dataForOrigin)) {
+              if (localStorage.getItem(key) === null) {
+                localStorage.setItem(key, value);
+              }
+            }
+          }
+        }, localStorageByOrigin);
+      }
     } catch (error) {
-      logger.warn({ message: 'Failed to load cookies for session', sessionId, error });
+      logger.warn({ message: 'Failed to load session data', sessionId, error });
     }
-  } else if (noCookies) {
-    logger.info({ message: 'Cookies disabled via cookies=false flag', sessionId });
   }
 
   // Configure download behavior via CDP
@@ -532,12 +550,12 @@ export const withBrowserSession = async <T>(
       }
     }
 
-    // Save cookies before destroying session (only for local mode, best-effort)
-    if (browserTaskMode === BrowserTaskMode.LOCAL && !noCookies) {
+    // Save cookies and localStorage before destroying session (if persistence is enabled)
+    if (persistSession) {
       try {
-        await saveCookiesForSession(context, sessionId);
+        await saveSessionDataViaSocket(context, page, sessionId);
       } catch (error) {
-        logger.warn({ message: 'Failed to save cookies before session destruction', sessionId, error });
+        logger.warn({ message: 'Failed to save session data', sessionId, error });
       }
     }
 
@@ -545,7 +563,7 @@ export const withBrowserSession = async <T>(
       sessionId,
       localRun: browserTaskMode === BrowserTaskMode.LOCAL,
       onPrem: browserTaskMode === BrowserTaskMode.ON_PREM,
-    }).catch(() => { });
+    }).catch(() => {});
   }
 };
 

package/src/types/Tools.types.ts

@@ -33,6 +33,7 @@ export interface RPATool<Input extends z.ZodSchema, Memory = any, Output extends
   proxyUser?: string; // Custom proxy username - used when proxyType is CUSTOM
   proxyPass?: string; // Custom proxy password - used when proxyType is CUSTOM
   browserTaskMode?: BrowserTaskMode; // Optional browser provider (local/cloud/onPrem)
+  persistSession?: boolean; // Session persistence: true (global persistence with cloud storage, default), false (no persistence)
   execute: (input: RPAToolExecuteInput<Input, Memory>) => Promise<ToolReturnType>;
 }