@minded-ai/mindedjs 2.0.27 → 2.0.28-beta.1

package/src/toolsLibrary/withBrowserSession.ts

@@ -0,0 +1,121 @@
+import { Browser, BrowserContext, chromium, Page } from "playwright";
+import { BrowserTaskMode } from "../browserTask/types";
+import { createBrowserSession, destroyBrowserSession } from "../browserTask/executeBrowserTask";
+import { logger } from "../utils/logger";
+import * as fs from 'fs';
+import * as path from 'path';
+import { CookieStore } from "../browserTask/CookieStore";
+
+// Initialize cookie store
+const cookieStore = new CookieStore(path.join(process.cwd(), 'local_storage', 'cookies'));
+
+// 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, browserTaskMode }: { sessionId: string, browserTaskMode: BrowserTaskMode }, callback: (page: Page) => Promise<T>): Promise<T> => {
+  const { cdpUrl } = await createBrowserSession({ sessionId, browserTaskMode });
+  if (!cdpUrl) {
+    throw new Error('CDP URL was not provided by the browser session.');
+  }
+  logger.info({ msg: 'Connecting to CDP', cdpUrl, sessionId });
+
+  let maxTries = 30;
+  let browser: Browser | null = null;
+  while (maxTries > 0) {
+    try {
+      browser = await chromium.connectOverCDP(cdpUrl);
+      break;
+    } catch (error) {
+      logger.warn({ msg: 'Failed to connect to CDP', sessionId, error });
+      maxTries--;
+      await delay(1000);
+    }
+  }
+  if (!browser) {
+    throw new Error('Failed to connect to CDP');
+  }
+  logger.info({ msg: 'Connected to CDP', cdpUrl, sessionId });
+  const context: BrowserContext = browser.contexts()[0] ?? await browser.newContext();
+  const page: Page = context.pages()[0] ?? await context.newPage();
+  logger.info({ msg: 'Created page', sessionId });
+
+  // Load cookies for this session (only for local mode, best-effort)
+  if (browserTaskMode === BrowserTaskMode.LOCAL) {
+    try {
+      await loadCookiesForSession(context, sessionId);
+    } catch (error) {
+      logger.warn({ message: 'Failed to load cookies for session', sessionId, error });
+    }
+  }
+
+  try {
+    return await callback(page);
+  } catch (e) {
+    logger.error({ msg: 'Error in browser session callback', sessionId, error: e });
+
+    // Save screenshot and HTML content for debugging
+    try {
+      const resultsDir = path.join(process.cwd(), 'rpaTestResults');
+      if (!fs.existsSync(resultsDir)) {
+        fs.mkdirSync(resultsDir, { recursive: true });
+      }
+
+      const screenshotPath = path.join(resultsDir, `screenshot.jpeg`);
+      const htmlPath = path.join(resultsDir, `content.html`);
+
+      // Take screenshot with 80% quality
+      await page.screenshot({ path: screenshotPath, type: 'jpeg', quality: 80 });
+      logger.info({ msg: 'Saved error screenshot', path: screenshotPath, sessionId });
+
+      // Save HTML content
+      const htmlContent = await page.content();
+      fs.writeFileSync(htmlPath, htmlContent, 'utf8');
+      logger.info({ msg: 'Saved error HTML content', path: htmlPath, sessionId });
+    } catch (saveError) {
+      logger.warn({ msg: 'Failed to save error artifacts', sessionId, error: saveError });
+    }
+
+    throw e;
+  } finally {
+    // Save cookies before destroying session (only for local mode, best-effort)
+    if (browserTaskMode === BrowserTaskMode.LOCAL) {
+      try {
+        await saveCookiesForSession(context, sessionId);
+      } catch (error) {
+        logger.warn({ message: 'Failed to save cookies before session destruction', sessionId, error });
+      }
+    }
+
+    destroyBrowserSession({ sessionId, localRun: browserTaskMode === BrowserTaskMode.LOCAL, onPrem: browserTaskMode === BrowserTaskMode.ON_PREM }).catch(() => { });
+  }
+}
+
+const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));

package/src/utils/parseDirectToolExecutionArgs.ts

@@ -0,0 +1,31 @@
+export function parseDirectToolExecutionArgs(args: string[]): { toolName: string; params: Record<string, any> } {
+  if (args.length === 0) {
+    throw new Error('Usage: npm run tool <toolName> [key=value ...]');
+  }
+
+  const toolName = args[0];
+  const params: Record<string, any> = {};
+
+  // Parse key=value pairs
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    const equalIndex = arg.indexOf('=');
+
+    if (equalIndex === -1) {
+      throw new Error(`Invalid argument format: ${arg}. Expected key=value`);
+    }
+
+    const key = arg.substring(0, equalIndex);
+    const rawValue = arg.substring(equalIndex + 1);
+
+    // Try to parse as JSON (for objects, arrays, booleans, numbers)
+    try {
+      params[key] = JSON.parse(rawValue);
+    } catch {
+      // If not valid JSON, treat as string
+      params[key] = rawValue;
+    }
+  }
+
+  return { toolName, params };
+}