donobu 5.56.0 → 5.57.0

package/dist/esm/managers/DonobuFlowsManager.js

@@ -195,7 +195,7 @@ class DonobuFlowsManager {
                 };
                 const flowsPersistence = await this.resolveLayerForFlowCreate(flowParams.testId ?? null);
                 const envData = await this.envDataManager.getByNames(flowMetadata.envVars ?? []);
-                const donobuFlow = new DonobuFlow_1.DonobuFlow(this, envData, flowsPersistence, gptClientData.gptClient, toolManager, interactionVisualizer, toolCallsOnStart, [], [], targetRuntime.inspector, flowMetadata, targetRuntime.controlPanel);
+                const donobuFlow = new DonobuFlow_1.DonobuFlow(this, envData, flowsPersistence, gptClientData.gptClient, toolManager, interactionVisualizer, toolCallsOnStart, [], [], targetRuntime.provider, flowMetadata, targetRuntime.controlPanel);
                 await flowsPersistence.setFlowMetadata(flowMetadata);
                 const flowHandle = {
                     donobuFlow: donobuFlow,
@@ -453,15 +453,7 @@ class DonobuFlowsManager {
             ? this.flowRuntime.get(flowId)
             : null;
         if (activeFlowHandle) {
-            activeFlowHandle.donobuFlow.metadata.nextState = 'FAILED';
-            // If the target is still connected, cancel will cause the flow to fail
-            // on its next iteration. For web flows, close the browser context.
-            if (activeFlowHandle.donobuFlow.targetInspector.connected) {
-                const target = activeFlowHandle.donobuFlow.targetInspector.target;
-                if (target.type === 'web' && target.current) {
-                    await target.current.context().close();
-                }
-            }
+            await activeFlowHandle.donobuFlow.cancel();
             return activeFlowHandle.donobuFlow.metadata;
         }
         return await this.getFlowById(flowId);

package/dist/esm/managers/FlowDependencyAnalyzer.d.ts

@@ -11,23 +11,11 @@ export declare class FlowDependencyAnalyzer {
      * Analyzes a collection of flows and builds a dependency graph based on browser state references.
      */
     static analyzeDependencies(flows: FlowMetadata[]): DependencyGraph;
-    /**
-     * Extracts dependencies for a single flow by analyzing its browser.initialState
-     */
-    private static extractDependencies;
     /**
      * Determines if a new flow should replace an existing flow when they have the same name.
      * Prefers flows with later completedAt times, treating null completedAt as "never completed".
      */
     static shouldReplaceFlow(existingFlow: FlowMetadata, newFlow: FlowMetadata): boolean;
-    /**
-     * Detects circular dependencies using DFS
-     */
-    private static detectCircularDependencies;
-    /**
-     * Calculates execution order using topological sort with parallel execution support
-     */
-    private static calculateExecutionOrder;
     /**
      * Validates that all flow dependencies can be resolved
      */
@@ -36,5 +24,17 @@ export declare class FlowDependencyAnalyzer {
      * Gets a human-readable summary of the dependency graph
      */
     static getDependencySummary(graph: DependencyGraph): string;
+    /**
+     * Extracts dependencies for a single flow by analyzing its browser.initialState
+     */
+    private static extractDependencies;
+    /**
+     * Detects circular dependencies using DFS
+     */
+    private static detectCircularDependencies;
+    /**
+     * Calculates execution order using topological sort with parallel execution support
+     */
+    private static calculateExecutionOrder;
 }
 //# sourceMappingURL=FlowDependencyAnalyzer.d.ts.map

package/dist/esm/managers/FlowDependencyAnalyzer.js

@@ -61,6 +61,83 @@ class FlowDependencyAnalyzer {
             executionOrder,
         };
     }
+    /**
+     * Determines if a new flow should replace an existing flow when they have the same name.
+     * Prefers flows with later completedAt times, treating null completedAt as "never completed".
+     */
+    static shouldReplaceFlow(existingFlow, newFlow) {
+        // If both flows have completedAt values, prefer the later one
+        if (existingFlow.completedAt !== null && newFlow.completedAt !== null) {
+            return newFlow.completedAt > existingFlow.completedAt;
+        }
+        // If only the new flow has a completedAt value, prefer it
+        if (existingFlow.completedAt === null && newFlow.completedAt !== null) {
+            return true;
+        }
+        // If only the existing flow has a completedAt value, keep it
+        if (existingFlow.completedAt !== null && newFlow.completedAt === null) {
+            return false;
+        }
+        // If neither has completedAt, prefer the one with the later startedAt
+        // (this handles flows that are still running or were interrupted)
+        if (existingFlow.startedAt !== null && newFlow.startedAt !== null) {
+            return newFlow.startedAt > existingFlow.startedAt;
+        }
+        // If only the new flow has startedAt, prefer it
+        if (existingFlow.startedAt === null && newFlow.startedAt !== null) {
+            return true;
+        }
+        // If only the existing flow has startedAt, keep it
+        if (existingFlow.startedAt !== null && newFlow.startedAt === null) {
+            return false;
+        }
+        // If we can't determine based on timestamps, keep the existing flow
+        return false;
+    }
+    /**
+     * Validates that all flow dependencies can be resolved
+     */
+    static validateDependencies(flows) {
+        try {
+            this.analyzeDependencies(flows);
+        }
+        catch (error) {
+            throw new Error(`Flow dependency validation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Gets a human-readable summary of the dependency graph
+     */
+    static getDependencySummary(graph) {
+        const lines = [];
+        lines.push(`Flow Dependency Analysis:`);
+        lines.push(`- Total flows: ${graph.flows.size}`);
+        lines.push(`- Independent flows: ${graph.independentFlows.length}`);
+        lines.push(`- Execution waves: ${graph.executionOrder.length}`);
+        lines.push('');
+        lines.push('Execution Order:');
+        graph.executionOrder.forEach((wave, index) => {
+            const waveNames = wave.map((flowId) => {
+                const flow = graph.flows.get(flowId);
+                return flow?.name || flowId;
+            });
+            lines.push(`  Wave ${index + 1}: ${waveNames.join(', ')}`);
+        });
+        lines.push('');
+        lines.push('Dependencies:');
+        graph.dependencies.forEach((deps, flowId) => {
+            if (deps.length > 0) {
+                const flow = graph.flows.get(flowId);
+                const flowName = flow?.name || flowId;
+                const depNames = deps.map((depId) => {
+                    const depFlow = graph.flows.get(depId);
+                    return depFlow?.name || depId;
+                });
+                lines.push(`  ${flowName} depends on: ${depNames.join(', ')}`);
+            }
+        });
+        return lines.join('\n');
+    }
     /**
      * Extracts dependencies for a single flow by analyzing its browser.initialState
      */
@@ -102,39 +179,6 @@ class FlowDependencyAnalyzer {
                 throw new Error(`Unknown browser state reference type: ${initialState.type}`);
         }
     }
-    /**
-     * Determines if a new flow should replace an existing flow when they have the same name.
-     * Prefers flows with later completedAt times, treating null completedAt as "never completed".
-     */
-    static shouldReplaceFlow(existingFlow, newFlow) {
-        // If both flows have completedAt values, prefer the later one
-        if (existingFlow.completedAt !== null && newFlow.completedAt !== null) {
-            return newFlow.completedAt > existingFlow.completedAt;
-        }
-        // If only the new flow has a completedAt value, prefer it
-        if (existingFlow.completedAt === null && newFlow.completedAt !== null) {
-            return true;
-        }
-        // If only the existing flow has a completedAt value, keep it
-        if (existingFlow.completedAt !== null && newFlow.completedAt === null) {
-            return false;
-        }
-        // If neither has completedAt, prefer the one with the later startedAt
-        // (this handles flows that are still running or were interrupted)
-        if (existingFlow.startedAt !== null && newFlow.startedAt !== null) {
-            return newFlow.startedAt > existingFlow.startedAt;
-        }
-        // If only the new flow has startedAt, prefer it
-        if (existingFlow.startedAt === null && newFlow.startedAt !== null) {
-            return true;
-        }
-        // If only the existing flow has startedAt, keep it
-        if (existingFlow.startedAt !== null && newFlow.startedAt === null) {
-            return false;
-        }
-        // If we can't determine based on timestamps, keep the existing flow
-        return false;
-    }
     /**
      * Detects circular dependencies using DFS
      */
@@ -198,50 +242,6 @@ class FlowDependencyAnalyzer {
         }
         return executionOrder;
     }
-    /**
-     * Validates that all flow dependencies can be resolved
-     */
-    static validateDependencies(flows) {
-        try {
-            this.analyzeDependencies(flows);
-        }
-        catch (error) {
-            throw new Error(`Flow dependency validation failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Gets a human-readable summary of the dependency graph
-     */
-    static getDependencySummary(graph) {
-        const lines = [];
-        lines.push(`Flow Dependency Analysis:`);
-        lines.push(`- Total flows: ${graph.flows.size}`);
-        lines.push(`- Independent flows: ${graph.independentFlows.length}`);
-        lines.push(`- Execution waves: ${graph.executionOrder.length}`);
-        lines.push('');
-        lines.push('Execution Order:');
-        graph.executionOrder.forEach((wave, index) => {
-            const waveNames = wave.map((flowId) => {
-                const flow = graph.flows.get(flowId);
-                return flow?.name || flowId;
-            });
-            lines.push(`  Wave ${index + 1}: ${waveNames.join(', ')}`);
-        });
-        lines.push('');
-        lines.push('Dependencies:');
-        graph.dependencies.forEach((deps, flowId) => {
-            if (deps.length > 0) {
-                const flow = graph.flows.get(flowId);
-                const flowName = flow?.name || flowId;
-                const depNames = deps.map((depId) => {
-                    const depFlow = graph.flows.get(depId);
-                    return depFlow?.name || depId;
-                });
-                lines.push(`  ${flowName} depends on: ${depNames.join(', ')}`);
-            }
-        });
-        return lines.join('\n');
-    }
 }
 exports.FlowDependencyAnalyzer = FlowDependencyAnalyzer;
 //# sourceMappingURL=FlowDependencyAnalyzer.js.map

package/dist/esm/managers/PageInspector.d.ts

@@ -60,6 +60,44 @@ export declare class PageInspector {
      *          run in the browser context before calling this class's methods.
      */
     constructor(interactableElementAttribute?: string, interactableAnnotationAttribute?: string);
+    /**
+     * Converts an HTML attribute to a JavaScript attribute. For example,
+     * "data-foo-bar" is turned into "fooBar". Notice the dropping of the "data-"
+     * prefix, and the conversion from kebab-case to camelCase.
+     */
+    static convertToJsAttribute(htmlAttribute: string): string;
+    /**
+     * An internal method that is injected into page/frame contexts to find and attribute interactable elements.
+     *
+     * This method:
+     * 1. Identifies potentially interactable elements using a comprehensive selector
+     * 2. Filters elements based on visibility, position in viewport, and interactability
+     * 3. Assigns unique sequential numeric values to the interactable attribute
+     *
+     * The method uses several criteria to determine if an element is truly interactable:
+     * - Element must be visible (non-zero dimensions, not hidden via CSS)
+     * - Element must have at least 50% of its area within the viewport
+     * - Element must not be disabled, inert, or have pointer-events:none
+     * - Element must be the topmost element at its coordinates (using point sampling)
+     *
+     * Special handling is provided for label elements, which will attribute their
+     * associated form controls as well.
+     *
+     * This method can process both standard DOM elements and elements within shadow roots,
+     * ensuring thorough coverage of modern web applications.
+     *
+     * @param arg - A tuple containing [offset: number, interactableAttribute: string]
+     *              where offset is the starting value for sequential numbering and
+     *              interactableAttribute is the attribute name to assign
+     * @returns The updated offset after assigning attributes (for sequential numbering across frames)
+     * @private
+     *
+     * @remarks
+     * This method is designed to be injected into the page context using page.evaluate()
+     * and should not be called directly from Node.js code.
+     */
+    private static attributeElementsInContext;
+    private static frameFilter;
     /**
      * Assigns a globally unique attribute to all visible and interactable elements in the page.
      *
@@ -215,43 +253,5 @@ export declare class PageInspector {
      * // htmlSnippet = "<button type=\"submit\">Submit</button>"
      */
     getHtmlSnippet(elementHandle: ElementHandle<HTMLElement | SVGElement>): Promise<string>;
-    /**
-     * Converts an HTML attribute to a JavaScript attribute. For example,
-     * "data-foo-bar" is turned into "fooBar". Notice the dropping of the "data-"
-     * prefix, and the conversion from kebab-case to camelCase.
-     */
-    static convertToJsAttribute(htmlAttribute: string): string;
-    /**
-     * An internal method that is injected into page/frame contexts to find and attribute interactable elements.
-     *
-     * This method:
-     * 1. Identifies potentially interactable elements using a comprehensive selector
-     * 2. Filters elements based on visibility, position in viewport, and interactability
-     * 3. Assigns unique sequential numeric values to the interactable attribute
-     *
-     * The method uses several criteria to determine if an element is truly interactable:
-     * - Element must be visible (non-zero dimensions, not hidden via CSS)
-     * - Element must have at least 50% of its area within the viewport
-     * - Element must not be disabled, inert, or have pointer-events:none
-     * - Element must be the topmost element at its coordinates (using point sampling)
-     *
-     * Special handling is provided for label elements, which will attribute their
-     * associated form controls as well.
-     *
-     * This method can process both standard DOM elements and elements within shadow roots,
-     * ensuring thorough coverage of modern web applications.
-     *
-     * @param arg - A tuple containing [offset: number, interactableAttribute: string]
-     *              where offset is the starting value for sequential numbering and
-     *              interactableAttribute is the attribute name to assign
-     * @returns The updated offset after assigning attributes (for sequential numbering across frames)
-     * @private
-     *
-     * @remarks
-     * This method is designed to be injected into the page context using page.evaluate()
-     * and should not be called directly from Node.js code.
-     */
-    private static attributeElementsInContext;
-    private static frameFilter;
 }
 //# sourceMappingURL=PageInspector.d.ts.map