donobu 5.27.2 → 5.27.3

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

@@ -108,24 +108,30 @@ export declare class DonobuFlow {
     /**
      * This method is called when a flow is complete (i.e. when {@link DonobuFlow.run} should return).
      *
-     * Browser session state and the final metadata write are committed by
-     * whichever code path produced the terminal state (transitionState for
-     * tool-driven completion; the on*Failure handlers for failure paths) —
-     * by the time we reach onComplete those have already happened.
+     * Browser session state and the terminal-state metadata write are
+     * committed by whichever code path produced the terminal state
+     * (transitionState for tool-driven completion; onTargetClosed /
+     * onPersistentGptFailure / onInsufficientQuota / onUnexpectedException
+     * for failure paths) — by the time we reach onComplete those have
+     * already happened. This method just runs the post-completion side
+     * effects.
      */
     private onComplete;
     /**
      * Persists the current browser session state if the flow's config has
-     * `persistState` enabled. Must be called BEFORE every site that commits
-     * a terminal `state` to persistence — otherwise a frontend that polls
-     * for the flow's state can observe "complete" between the metadata
-     * write and the session-state upload, fire an eager browser-state
-     * fetch (e.g. FlowDeveloperTools auto-loads on terminal), and 404 until
-     * the upload finishes.
+     * `persistState` enabled. Must be called BEFORE the in-memory `state`
+     * is mutated to a terminal value at every site that produces a
+     * terminal state — otherwise FlowCatalog.getFlowById can read the
+     * live FlowMetadata object (LOCAL deployments) and a frontend that
+     * observes the terminal state will race the (potentially network-
+     * bound) upload here, getting a 404 from a subsequent browser-state
+     * fetch.
      *
      * The browser context typically survives all-pages-closed (the read
-     * goes against the context, not a specific page), so this is also
-     * safe to call from the failure handlers like onTargetClosed.
+     * goes against the context, not a specific page), so this is safe to
+     * call from failure handlers like onTargetClosed. If the read does
+     * fail, persistSessionState catches and logs internally — it doesn't
+     * propagate.
      */
     private persistTerminalSessionStateIfNeeded;
     /**

package/dist/esm/managers/DonobuFlow.js

@@ -215,10 +215,18 @@ class DonobuFlow {
     async onTargetClosed() {
         const result = await this.targetInspector.handleTargetClosed();
         if (!result.recovered) {
-            this.metadata.state = 'FAILED';
+            // Persist browser state BEFORE flipping the in-memory `state` to
+            // a terminal value. FlowCatalog.getFlowById serves the *live*
+            // FlowMetadata object for LOCAL deployments, so the next frontend
+            // poll observes terminal state the moment we mutate `state`.
+            // If we do that before the (potentially network-bound) session
+            // upload, an eager browser-state fetch from the frontend (e.g.
+            // FlowDeveloperTools auto-loads on terminal) races the upload and
+            // 404s. Same rationale as the ordering in transitionState.
             Logger_1.appLogger.error(result.reason);
-            this.metadata.result = { failed: result.reason };
             await this.persistTerminalSessionStateIfNeeded();
+            this.metadata.result = { failed: result.reason };
+            this.metadata.state = 'FAILED';
             await this.persistence.setFlowMetadata(this.metadata);
         }
     }
@@ -227,13 +235,13 @@ class DonobuFlow {
      * are internal retries). This method will mark the flow as a failure.
      */
     async onPersistentGptFailure(error) {
-        this.metadata.state = 'FAILED';
         Logger_1.appLogger.error(`Stopped flow due to the ${this.gptClient?.config.type} GPT platform throwing an internal error!`, error);
+        await this.persistTerminalSessionStateIfNeeded();
         this.metadata.result = {
             failed: `Stopped flow due to the ${this.gptClient?.config.type} GPT platform throwing an internal error!`,
             context: error.message,
         };
-        await this.persistTerminalSessionStateIfNeeded();
+        this.metadata.state = 'FAILED';
         await this.persistence.setFlowMetadata(this.metadata);
     }
     /**
@@ -241,15 +249,15 @@ class DonobuFlow {
      * usage quota or credits have been exhausted (HTTP 402).
      */
     async onInsufficientQuota(error) {
-        this.metadata.state = 'FAILED';
         const platform = error.gptPlatform;
         const isDonobu = platform === 'DONOBU';
         const failedMessage = isDonobu
             ? 'Your Donobu AI credits have been exhausted. Please add more credits to your account to continue running flows.'
             : `Your ${platform} API quota has been exhausted. Please check your account's billing and usage limits; this may happen if there is a lack of funds in the account`;
         Logger_1.appLogger.error(failedMessage, error);
-        this.metadata.result = { failed: failedMessage };
         await this.persistTerminalSessionStateIfNeeded();
+        this.metadata.result = { failed: failedMessage };
+        this.metadata.state = 'FAILED';
         await this.persistence.setFlowMetadata(this.metadata);
     }
     /**
@@ -339,21 +347,24 @@ class DonobuFlow {
      * method will mark the flow as a failure.
      */
     async onUnexpectedException(error) {
-        this.metadata.state = 'FAILED';
         Logger_1.appLogger.error('Stopped flow due to exception!', error);
+        await this.persistTerminalSessionStateIfNeeded();
         this.metadata.result = {
             failed: 'Internal error 🙈',
         };
-        await this.persistTerminalSessionStateIfNeeded();
+        this.metadata.state = 'FAILED';
         await this.persistence.setFlowMetadata(this.metadata);
     }
     /**
      * This method is called when a flow is complete (i.e. when {@link DonobuFlow.run} should return).
      *
-     * Browser session state and the final metadata write are committed by
-     * whichever code path produced the terminal state (transitionState for
-     * tool-driven completion; the on*Failure handlers for failure paths) —
-     * by the time we reach onComplete those have already happened.
+     * Browser session state and the terminal-state metadata write are
+     * committed by whichever code path produced the terminal state
+     * (transitionState for tool-driven completion; onTargetClosed /
+     * onPersistentGptFailure / onInsufficientQuota / onUnexpectedException
+     * for failure paths) — by the time we reach onComplete those have
+     * already happened. This method just runs the post-completion side
+     * effects.
      */
     async onComplete() {
         DonobuFlow.invokeFlowFinishedCallback(this.metadata.callbackUrl, this.metadata.id);
@@ -361,16 +372,19 @@ class DonobuFlow {
     }
     /**
      * Persists the current browser session state if the flow's config has
-     * `persistState` enabled. Must be called BEFORE every site that commits
-     * a terminal `state` to persistence — otherwise a frontend that polls
-     * for the flow's state can observe "complete" between the metadata
-     * write and the session-state upload, fire an eager browser-state
-     * fetch (e.g. FlowDeveloperTools auto-loads on terminal), and 404 until
-     * the upload finishes.
+     * `persistState` enabled. Must be called BEFORE the in-memory `state`
+     * is mutated to a terminal value at every site that produces a
+     * terminal state — otherwise FlowCatalog.getFlowById can read the
+     * live FlowMetadata object (LOCAL deployments) and a frontend that
+     * observes the terminal state will race the (potentially network-
+     * bound) upload here, getting a 404 from a subsequent browser-state
+     * fetch.
      *
      * The browser context typically survives all-pages-closed (the read
-     * goes against the context, not a specific page), so this is also
-     * safe to call from the failure handlers like onTargetClosed.
+     * goes against the context, not a specific page), so this is safe to
+     * call from failure handlers like onTargetClosed. If the read does
+     * fail, persistSessionState catches and logs internally — it doesn't
+     * propagate.
      */
     async persistTerminalSessionStateIfNeeded() {
         if (this.metadata.web?.browser?.persistState) {
@@ -647,10 +661,8 @@ Message: ${dialog.message()}`;
         // this, then someone polling for a flow's state may see the flow
         // finished but still see a null result.
         //
-        // The same rationale applies to the browser session state: an eager
-        // fetch from the frontend (e.g. FlowDeveloperTools auto-loads on
-        // terminal state) would otherwise race the upload that onComplete
-        // performs and 404 until the user manually refreshed.
+        // The same rationale applies to the browser session state — see
+        // persistTerminalSessionStateIfNeeded for the full ordering note.
         if ((0, FlowMetadata_1.isComplete)(nextState)) {
             this.metadata.result = await this.createResultJson(nextState);
             await this.persistTerminalSessionStateIfNeeded();

package/dist/managers/DonobuFlow.d.ts

@@ -108,24 +108,30 @@ export declare class DonobuFlow {
     /**
      * This method is called when a flow is complete (i.e. when {@link DonobuFlow.run} should return).
      *
-     * Browser session state and the final metadata write are committed by
-     * whichever code path produced the terminal state (transitionState for
-     * tool-driven completion; the on*Failure handlers for failure paths) —
-     * by the time we reach onComplete those have already happened.
+     * Browser session state and the terminal-state metadata write are
+     * committed by whichever code path produced the terminal state
+     * (transitionState for tool-driven completion; onTargetClosed /
+     * onPersistentGptFailure / onInsufficientQuota / onUnexpectedException
+     * for failure paths) — by the time we reach onComplete those have
+     * already happened. This method just runs the post-completion side
+     * effects.
      */
     private onComplete;
     /**
      * Persists the current browser session state if the flow's config has
-     * `persistState` enabled. Must be called BEFORE every site that commits
-     * a terminal `state` to persistence — otherwise a frontend that polls
-     * for the flow's state can observe "complete" between the metadata
-     * write and the session-state upload, fire an eager browser-state
-     * fetch (e.g. FlowDeveloperTools auto-loads on terminal), and 404 until
-     * the upload finishes.
+     * `persistState` enabled. Must be called BEFORE the in-memory `state`
+     * is mutated to a terminal value at every site that produces a
+     * terminal state — otherwise FlowCatalog.getFlowById can read the
+     * live FlowMetadata object (LOCAL deployments) and a frontend that
+     * observes the terminal state will race the (potentially network-
+     * bound) upload here, getting a 404 from a subsequent browser-state
+     * fetch.
      *
      * The browser context typically survives all-pages-closed (the read
-     * goes against the context, not a specific page), so this is also
-     * safe to call from the failure handlers like onTargetClosed.
+     * goes against the context, not a specific page), so this is safe to
+     * call from failure handlers like onTargetClosed. If the read does
+     * fail, persistSessionState catches and logs internally — it doesn't
+     * propagate.
      */
     private persistTerminalSessionStateIfNeeded;
     /**

package/dist/managers/DonobuFlow.js

@@ -215,10 +215,18 @@ class DonobuFlow {
     async onTargetClosed() {
         const result = await this.targetInspector.handleTargetClosed();
         if (!result.recovered) {
-            this.metadata.state = 'FAILED';
+            // Persist browser state BEFORE flipping the in-memory `state` to
+            // a terminal value. FlowCatalog.getFlowById serves the *live*
+            // FlowMetadata object for LOCAL deployments, so the next frontend
+            // poll observes terminal state the moment we mutate `state`.
+            // If we do that before the (potentially network-bound) session
+            // upload, an eager browser-state fetch from the frontend (e.g.
+            // FlowDeveloperTools auto-loads on terminal) races the upload and
+            // 404s. Same rationale as the ordering in transitionState.
             Logger_1.appLogger.error(result.reason);
-            this.metadata.result = { failed: result.reason };
             await this.persistTerminalSessionStateIfNeeded();
+            this.metadata.result = { failed: result.reason };
+            this.metadata.state = 'FAILED';
             await this.persistence.setFlowMetadata(this.metadata);
         }
     }
@@ -227,13 +235,13 @@ class DonobuFlow {
      * are internal retries). This method will mark the flow as a failure.
      */
     async onPersistentGptFailure(error) {
-        this.metadata.state = 'FAILED';
         Logger_1.appLogger.error(`Stopped flow due to the ${this.gptClient?.config.type} GPT platform throwing an internal error!`, error);
+        await this.persistTerminalSessionStateIfNeeded();
         this.metadata.result = {
             failed: `Stopped flow due to the ${this.gptClient?.config.type} GPT platform throwing an internal error!`,
             context: error.message,
         };
-        await this.persistTerminalSessionStateIfNeeded();
+        this.metadata.state = 'FAILED';
         await this.persistence.setFlowMetadata(this.metadata);
     }
     /**
@@ -241,15 +249,15 @@ class DonobuFlow {
      * usage quota or credits have been exhausted (HTTP 402).
      */
     async onInsufficientQuota(error) {
-        this.metadata.state = 'FAILED';
         const platform = error.gptPlatform;
         const isDonobu = platform === 'DONOBU';
         const failedMessage = isDonobu
             ? 'Your Donobu AI credits have been exhausted. Please add more credits to your account to continue running flows.'
             : `Your ${platform} API quota has been exhausted. Please check your account's billing and usage limits; this may happen if there is a lack of funds in the account`;
         Logger_1.appLogger.error(failedMessage, error);
-        this.metadata.result = { failed: failedMessage };
         await this.persistTerminalSessionStateIfNeeded();
+        this.metadata.result = { failed: failedMessage };
+        this.metadata.state = 'FAILED';
         await this.persistence.setFlowMetadata(this.metadata);
     }
     /**
@@ -339,21 +347,24 @@ class DonobuFlow {
      * method will mark the flow as a failure.
      */
     async onUnexpectedException(error) {
-        this.metadata.state = 'FAILED';
         Logger_1.appLogger.error('Stopped flow due to exception!', error);
+        await this.persistTerminalSessionStateIfNeeded();
         this.metadata.result = {
             failed: 'Internal error 🙈',
         };
-        await this.persistTerminalSessionStateIfNeeded();
+        this.metadata.state = 'FAILED';
         await this.persistence.setFlowMetadata(this.metadata);
     }
     /**
      * This method is called when a flow is complete (i.e. when {@link DonobuFlow.run} should return).
      *
-     * Browser session state and the final metadata write are committed by
-     * whichever code path produced the terminal state (transitionState for
-     * tool-driven completion; the on*Failure handlers for failure paths) —
-     * by the time we reach onComplete those have already happened.
+     * Browser session state and the terminal-state metadata write are
+     * committed by whichever code path produced the terminal state
+     * (transitionState for tool-driven completion; onTargetClosed /
+     * onPersistentGptFailure / onInsufficientQuota / onUnexpectedException
+     * for failure paths) — by the time we reach onComplete those have
+     * already happened. This method just runs the post-completion side
+     * effects.
      */
     async onComplete() {
         DonobuFlow.invokeFlowFinishedCallback(this.metadata.callbackUrl, this.metadata.id);
@@ -361,16 +372,19 @@ class DonobuFlow {
     }
     /**
      * Persists the current browser session state if the flow's config has
-     * `persistState` enabled. Must be called BEFORE every site that commits
-     * a terminal `state` to persistence — otherwise a frontend that polls
-     * for the flow's state can observe "complete" between the metadata
-     * write and the session-state upload, fire an eager browser-state
-     * fetch (e.g. FlowDeveloperTools auto-loads on terminal), and 404 until
-     * the upload finishes.
+     * `persistState` enabled. Must be called BEFORE the in-memory `state`
+     * is mutated to a terminal value at every site that produces a
+     * terminal state — otherwise FlowCatalog.getFlowById can read the
+     * live FlowMetadata object (LOCAL deployments) and a frontend that
+     * observes the terminal state will race the (potentially network-
+     * bound) upload here, getting a 404 from a subsequent browser-state
+     * fetch.
      *
      * The browser context typically survives all-pages-closed (the read
-     * goes against the context, not a specific page), so this is also
-     * safe to call from the failure handlers like onTargetClosed.
+     * goes against the context, not a specific page), so this is safe to
+     * call from failure handlers like onTargetClosed. If the read does
+     * fail, persistSessionState catches and logs internally — it doesn't
+     * propagate.
      */
     async persistTerminalSessionStateIfNeeded() {
         if (this.metadata.web?.browser?.persistState) {
@@ -647,10 +661,8 @@ Message: ${dialog.message()}`;
         // this, then someone polling for a flow's state may see the flow
         // finished but still see a null result.
         //
-        // The same rationale applies to the browser session state: an eager
-        // fetch from the frontend (e.g. FlowDeveloperTools auto-loads on
-        // terminal state) would otherwise race the upload that onComplete
-        // performs and 404 until the user manually refreshed.
+        // The same rationale applies to the browser session state — see
+        // persistTerminalSessionStateIfNeeded for the full ordering note.
         if ((0, FlowMetadata_1.isComplete)(nextState)) {
             this.metadata.result = await this.createResultJson(nextState);
             await this.persistTerminalSessionStateIfNeeded();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "donobu",
-  "version": "5.27.2",
+  "version": "5.27.3",
   "description": "Create browser automations with an LLM agent and replay them as Playwright scripts.",
   "main": "dist/main.js",
   "module": "dist/esm/main.js",