@minded-ai/mindedjs 2.0.28-beta.2 → 2.0.29

package/src/toolsLibrary/withBrowserSession.ts

@@ -1,124 +0,0 @@
-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)
-  const noCookies = process.env.MINDED_NO_COOKIES === 'true';
-  if (browserTaskMode === BrowserTaskMode.LOCAL && !noCookies) {
-    try {
-      await loadCookiesForSession(context, sessionId);
-    } catch (error) {
-      logger.warn({ message: 'Failed to load cookies for session', sessionId, error });
-    }
-  } else if (noCookies) {
-    logger.info({ message: 'Cookies disabled via --noCookies flag', sessionId });
-  }
-
-  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 && !noCookies) {
-      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

@@ -1,46 +0,0 @@
-export function parseDirectToolExecutionArgs(args: string[]): {
-  toolName: string;
-  params: Record<string, any>;
-  flags: { noCookies: boolean }
-} {
-  if (args.length === 0) {
-    throw new Error('Usage: npm run tool <toolName> [key=value ...] [--noCookies]');
-  }
-
-  const toolName = args[0];
-  const params: Record<string, any> = {};
-  const flags = {
-    noCookies: false,
-  };
-
-  // Parse arguments
-  for (let i = 1; i < args.length; i++) {
-    const arg = args[i];
-
-    // Check for flags
-    if (arg === '--noCookies') {
-      flags.noCookies = true;
-      continue;
-    }
-
-    // Parse key=value pairs
-    const equalIndex = arg.indexOf('=');
-
-    if (equalIndex === -1) {
-      throw new Error(`Invalid argument format: ${arg}. Expected key=value or --flagName`);
-    }
-
-    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, flags };
-}