@minded-ai/mindedjs 3.1.21 → 3.1.23

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/Flows.types.ts

@@ -1,9 +1,5 @@
 import { LLMConfig } from './LLM.types';
 import { ToolType } from './Tools.types';
-export interface Position {
-  x: number;
-  y: number;
-}
 
 export enum NodeType {
   TRIGGER = 'trigger',
@@ -24,7 +20,6 @@ export enum EdgeType {
 export interface BaseNode {
   name: string;
   type: NodeType;
-  position?: Position;
   humanInTheLoop?: boolean;
   canStayOnNode?: boolean;
   displayName: string;

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>;
 }