@minded-ai/mindedjs 2.0.4 → 2.0.5-beta.10

package/src/browserTask/executeBrowserTask.ts

@@ -1,17 +1,32 @@
+import { exec as execCb } from 'node:child_process';
 import { logger } from '../utils/logger';
 import { mindedConnection } from '../platform/mindedConnection';
+import path from 'path';
 import {
   mindedConnectionSocketMessageType,
   CreateBrowserSessionResponse,
   InvokeBrowserTaskResponse,
   CreateBrowserSessionRequest,
   InvokeBrowserTaskRequest,
+  DestroyBrowserSessionRequest,
+  DestroyBrowserSessionResponse,
 } from '../platform/mindedConnectionTypes';
+import { promisify } from 'node:util';
+import { kill, getOrStartLocalCDP } from './localBrowserTask';
+const exec = promisify(execCb);
 
 // Socket-based browser task functions
-export const createBrowserSession = async (proxy?: string, onPrem?: boolean): Promise<CreateBrowserSessionResponse> => {
+export const createBrowserSession = async ({ sessionId, proxy, onPrem, localRun }: { sessionId: string, proxy?: string, onPrem?: boolean, localRun?: boolean }): Promise<CreateBrowserSessionResponse> => {
   logger.debug({ msg: 'Creating browser session via socket', proxy });
 
+  if (localRun) {
+    const { cdpUrl } = await getOrStartLocalCDP({ headless: false });
+    return {
+      sessionId,
+      cdpUrl
+    }
+  }
+
   const response = await mindedConnection.awaitEmit<CreateBrowserSessionRequest, CreateBrowserSessionResponse>(
     mindedConnectionSocketMessageType.CREATE_BROWSER_SESSION,
     {
@@ -36,6 +51,35 @@ export const createBrowserSession = async (proxy?: string, onPrem?: boolean): Pr
   return response;
 };
 
+export const destroyBrowserSession = async (sessionId: string, onPrem?: boolean, localRun?: boolean): Promise<DestroyBrowserSessionResponse> => {
+  logger.debug({ msg: 'Destroying browser session via socket', sessionId, onPrem });
+
+  if (localRun) {
+    await kill();
+    return {
+      success: true,
+    };
+  }
+
+  const response = await mindedConnection.awaitEmit<DestroyBrowserSessionRequest, DestroyBrowserSessionResponse>(
+    mindedConnectionSocketMessageType.DESTROY_BROWSER_SESSION,
+    {
+      type: mindedConnectionSocketMessageType.DESTROY_BROWSER_SESSION,
+      sessionId,
+      onPrem,
+    },
+    30000,
+  );
+
+  if (response.error) {
+    logger.error({ msg: 'Failed to destroy browser session', error: response.error, sessionId });
+    throw new Error(response.error);
+  }
+
+  logger.debug({ msg: 'Browser session destroyed successfully', sessionId });
+  return response;
+};
+
 export const invokeBrowserTask = async (
   sessionId: string,
   cdpUrl: string,
@@ -43,6 +87,7 @@ export const invokeBrowserTask = async (
   keepAlive?: boolean,
   hooks?: { name: string }[],
   onPrem?: boolean,
+  localRun?: boolean,
   toolSchemas?: any[],
   outputSchema?: {
     name: string;
@@ -62,6 +107,19 @@ export const invokeBrowserTask = async (
   });
 
   try {
+
+    if (localRun) {
+      const pythonScriptPath = path.resolve(__dirname, 'executeBrowserTask.py');
+      const command = `uv run ${pythonScriptPath} "${sessionId}" "${cdpUrl}" "${task.replace(/"/g, '\\"')}"`;
+      const { stdout, stderr } = await exec(command);
+      logger.info({ message: 'Operator finished', stdout, stderr });
+      return {
+        result: stdout,
+        steps: [],
+        recordings: [],
+      };
+    }
+
     const response = await mindedConnection.awaitEmit<InvokeBrowserTaskRequest, InvokeBrowserTaskResponse>(
       mindedConnectionSocketMessageType.INVOKE_BROWSER_TASK,
       {

package/src/browserTask/localBrowserTask.ts

@@ -0,0 +1,195 @@
+// getOrStartLocalCDP.ts
+import { spawn, ChildProcess } from "child_process";
+import * as fs from "fs/promises";
+import * as fscb from "fs";
+import * as path from "path";
+import * as http from "http";
+import { chromium } from "playwright";
+
+let localBrowserTask: {
+  cdpUrl: string;
+  proc: ChildProcess;
+} | null = null;
+
+export type StartChromiumOptions = {
+  /** Headless by default. Set to false to see a window. */
+  headless?: boolean;
+  /** Extra CLI flags to pass to Chromium. */
+  extraArgs?: string[];
+  /** Provide your own user-data-dir. If omitted, a temp dir is created and later removable via `kill()`. */
+  userDataDir?: string;
+  /** Extra env vars. */
+  env?: NodeJS.ProcessEnv;
+  /** How long to wait for the DevTools port to come up (ms). Default: 10000 */
+  timeoutMs?: number;
+};
+
+/**
+ * Launch Chromium with --remote-debugging-port=0 and return the CDP ws URL.
+ * Works with Chrome/Chromium/Chrome for Testing.
+ */
+export async function getOrStartLocalCDP(
+  opts: StartChromiumOptions
+): Promise<{ cdpUrl: string }> {
+
+  if (localBrowserTask) {
+    return {
+      cdpUrl: localBrowserTask.cdpUrl,
+    };
+  }
+
+  const {
+    headless = false,
+    extraArgs = [],
+    env,
+    timeoutMs = 10_000,
+  } = opts;
+
+  const executablePath = chromium.executablePath();
+
+  const profileDir = path.join(__dirname, "profile");
+  await fs.mkdir(profileDir, { recursive: true });
+
+  const userDataDir = opts.userDataDir ?? profileDir;
+
+  const args = [
+    "--remote-debugging-port=0", // let Chrome choose a free port
+    `--user-data-dir=${userDataDir}`,
+    "--no-first-run",
+    "--no-default-browser-check",
+    ...(headless ? ["--headless=new", "--disable-gpu"] : []),
+    // Add your own flags if needed (e.g., '--no-sandbox' in some containers)
+    ...extraArgs,
+    "about:blank",
+  ];
+
+  const proc = spawn(executablePath, args, {
+    stdio: ["ignore", "ignore", "pipe"], // stderr is useful for debugging
+    env: { ...process.env, ...env },
+  });
+
+  // If Chromium dies early, surface the error.
+  const earlyExit = new Promise<never>((_, reject) => {
+    proc.once("exit", (code, signal) => {
+      reject(
+        new Error(`Chromium exited prematurely (code=${code}, signal=${signal}).`)
+      );
+    });
+  });
+
+  const devtoolsPortFile = path.join(userDataDir, "DevToolsActivePort");
+
+  // Wait for DevToolsActivePort file to appear, then read it for port + browserId.
+  const whenReady = (async () => {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+      try {
+        // Access succeeds once the file is written.
+        await fs.access(devtoolsPortFile, fscb.constants.F_OK);
+        break;
+      } catch {
+        await delay(50);
+      }
+    }
+    // If still not there, bail.
+    await fs.access(devtoolsPortFile, fscb.constants.F_OK).catch(() => {
+      throw new Error(
+        `Timed out after ${timeoutMs}ms waiting for DevToolsActivePort at ${devtoolsPortFile}`
+      );
+    });
+
+    const raw = await fs.readFile(devtoolsPortFile, "utf8");
+    const [portLine, browserIdLine] = raw.trim().split(/\r?\n/);
+    const port = Number(portLine);
+    if (!Number.isFinite(port)) {
+      throw new Error(`Invalid DevTools port read from file: "${portLine}"`);
+    }
+
+    // Optional: ping /json/version to ensure the endpoint is responsive.
+    await waitForHttpOk(`http://127.0.0.1:${port}/json/version`, timeoutMs);
+
+    const browserId = (browserIdLine || "").trim();
+    const cdpUrl =
+      browserId.length > 0
+        ? `ws://127.0.0.1:${port}/devtools/browser/${browserId}`
+        : // Fallback: some builds don't include the second line; /json/version has the ws url too.
+        await fetchWsFromVersionEndpoint(port, timeoutMs);
+
+    localBrowserTask = {
+      cdpUrl,
+      proc,
+    };
+
+    return { cdpUrl };
+  })();
+
+  const { cdpUrl } = await Promise.race([whenReady, earlyExit]);
+
+  return { cdpUrl };
+}
+
+// ---- helpers ----
+function delay(ms: number) {
+  return new Promise<void>((r) => setTimeout(r, ms));
+}
+
+async function waitForHttpOk(url: string, timeoutMs: number) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const ok = await httpGetOk(url).catch(() => false);
+    if (ok) return;
+    await delay(50);
+  }
+  throw new Error(`Timed out after ${timeoutMs}ms waiting for ${url}`);
+}
+
+function httpGetOk(urlStr: string): Promise<boolean> {
+  return new Promise((resolve, reject) => {
+    const req = http.get(urlStr, (res) => {
+      // Drain data to allow socket reuse.
+      res.resume();
+      resolve(res.statusCode === 200);
+    });
+    req.on("error", reject);
+    req.setTimeout(3000, () => {
+      req.destroy(new Error("HTTP timeout"));
+    });
+  });
+}
+
+async function fetchWsFromVersionEndpoint(
+  port: number,
+  timeoutMs: number
+): Promise<string> {
+  const urlStr = `http://127.0.0.1:${port}/json/version`;
+  const body = await httpGetBody(urlStr, timeoutMs);
+  const parsed = JSON.parse(body);
+  if (!parsed.webSocketDebuggerUrl) {
+    throw new Error(`No webSocketDebuggerUrl in ${urlStr} response`);
+  }
+  return parsed.webSocketDebuggerUrl as string;
+}
+
+function httpGetBody(urlStr: string, timeoutMs: number): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const req = http.get(urlStr, (res) => {
+      let data = "";
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => {
+        if (res.statusCode === 200) resolve(data);
+        else reject(new Error(`HTTP ${res.statusCode}: ${data}`));
+      });
+    });
+    req.on("error", reject);
+    req.setTimeout(timeoutMs, () => req.destroy(new Error("HTTP timeout")));
+  });
+}
+
+export async function kill() {
+  if (localBrowserTask) {
+    localBrowserTask.proc.kill("SIGTERM");
+    await delay(300);
+    localBrowserTask.proc.kill("SIGKILL");
+  }
+}

package/src/edges/createPromptRouter.ts

@@ -116,12 +116,12 @@ export const createPromptRouter = ({
     // Define response schema
     const responseSchema = includeReasoning
       ? z.object({
-          nextNodeId: z.string(),
-          reasoning: z.string(),
-        })
+        nextNodeId: z.string(),
+        reasoning: z.string(),
+      })
       : z.object({
-          nextNodeId: z.string(),
-        });
+        nextNodeId: z.string(),
+      });
 
     let attempts = 0;
     let lastError: Error | null = null;
@@ -194,21 +194,13 @@ export const createPromptRouter = ({
         });
 
         if (attempts >= maxRetries) {
-          // If all retries failed, return the first available edge as fallback
-          const fallbackNode = edges[0]?.target;
           logger.error({
-            msg: '[Router] Prompt router reached max retries, using fallback',
-            fallbackNode,
+            msg: '[Router] Prompt router reached max retries',
             lastError: lastError.message,
             sessionId: state.sessionId,
             edges,
           });
-
-          if (!fallbackNode) {
-            throw new Error('No edges available for routing');
-          }
-
-          return fallbackNode;
+          throw new Error('Prompt router reached max retries, no edges available for routing');
         }
       }
     }

package/src/index.ts

@@ -97,4 +97,6 @@ export type { ExtractionSchema, ExtractionConfig, ExtractionResult } from './too
 export { AgentEvents } from './events/AgentEvents';
 export type { AgentEventRequestPayloads, AgentEventResponsePayloads } from './events/AgentEvents';
 
+export { createBrowserSession, destroyBrowserSession } from './browserTask/executeBrowserTask';
+
 export { LLMDebugCallbackHandler } from './debugging';

package/src/nodes/addBrowserTaskNode.ts

@@ -54,7 +54,7 @@ export const addBrowserTaskNode = async ({ graph, node, agent, llm }: AddBrowser
     const zodSchema = z.object(schemaFields);
 
     // Create langchain tool
-    const tool = langchainTool(() => {}, {
+    const tool = langchainTool(() => { }, {
       name: 'browser-task',
       description: node.prompt,
       schema: zodSchema,
@@ -100,7 +100,12 @@ ${compiledPrompt}
 ${Object.keys(inputParams).length > 0 ? `# Input parameters:\n${JSON.stringify(inputParams, null, 2)}\n\n` : ''}`;
 
       // Create browser session using socket
-      const session = await createBrowserSession(node.proxy, node.onPrem);
+      const session = await createBrowserSession({
+        sessionId: state.sessionId,
+        proxy: node.proxy,
+        onPrem: node.onPrem,
+        localRun: node.localRun,
+      });
 
       if (!session.sessionId || !session.cdpUrl) {
         throw new Error('Failed to create browser session: missing session details');

package/src/nodes/addBrowserTaskRunNode.ts

@@ -57,6 +57,7 @@ export const addBrowserTaskRunNode = async ({ graph, browserTaskNode, attachedTo
         keepAlive,
         hooks,
         browserTaskNode.onPrem,
+        browserTaskNode.localRun,
         toolSchemas,
         outputSchema,
       );

package/src/platform/mindedConnectionTypes.ts

@@ -42,6 +42,7 @@ export enum mindedConnectionSocketMessageType {
   SDK_VERSION_MISMATCH = 'sdk-version-mismatch', // Browser Task
   CREATE_BROWSER_SESSION = 'create-browser-session',
   INVOKE_BROWSER_TASK = 'invoke-browser-task',
+  DESTROY_BROWSER_SESSION = 'destroy-browser-session',
   // Interrupt Session Management
   INTERRUPT_SESSION_IS_PROCESSED = 'interrupt-session-is-processed',
   INTERRUPT_SESSION_LOCK = 'interrupt-session-lock',
@@ -85,6 +86,7 @@ export type mindedConnectionSocketMessageTypeMap = {
   [mindedConnectionSocketMessageType.UPDATE_STATE]: UpdateStateRequest;
   [mindedConnectionSocketMessageType.CREATE_BROWSER_SESSION]: CreateBrowserSessionRequest;
   [mindedConnectionSocketMessageType.INVOKE_BROWSER_TASK]: InvokeBrowserTaskRequest;
+  [mindedConnectionSocketMessageType.DESTROY_BROWSER_SESSION]: DestroyBrowserSessionRequest;
   // Interrupt Session Management
   [mindedConnectionSocketMessageType.INTERRUPT_SESSION_IS_PROCESSED]: InterruptSessionIsProcessedRequest;
   [mindedConnectionSocketMessageType.INTERRUPT_SESSION_LOCK]: InterruptSessionLockRequest;
@@ -423,6 +425,16 @@ export interface CreateBrowserSessionResponse extends BaseSdkConnectionSocketMes
   liveViewUrl?: string;
 }
 
+export interface DestroyBrowserSessionRequest extends BasemindedConnectionSocketMessage {
+  type: mindedConnectionSocketMessageType.DESTROY_BROWSER_SESSION;
+  sessionId: string;
+  onPrem?: boolean;
+}
+
+export interface DestroyBrowserSessionResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
 export interface InvokeBrowserTaskRequest extends BasemindedConnectionSocketMessage {
   type: mindedConnectionSocketMessageType.INVOKE_BROWSER_TASK;
   cdpUrl: string;

package/src/types/Flows.types.ts

@@ -121,6 +121,7 @@ export interface BrowserTaskNode extends BaseNode {
   proxy?: string; // 2-digit country code like 'IL'
   hooks?: { name: string }[]; // Array of hooks to be passed to the browser-use lambda
   onPrem?: boolean;
+  localRun?: boolean;
 }
 
 export type TriggerNode = AppTriggerNode | WebhookTriggerNode | ManualTriggerNode | VoiceTriggerNode | InterfaceTriggerNode;