donobu 5.27.1 → 5.27.3

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

@@ -107,8 +107,33 @@ export declare class DonobuFlow {
     private onUnexpectedException;
     /**
      * This method is called when a flow is complete (i.e. when {@link DonobuFlow.run} should return).
+     *
+     * 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 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 safe to
+     * call from failure handlers like onTargetClosed. If the read does
+     * fail, persistSessionState catches and logs internally — it doesn't
+     * propagate.
+     */
+    private persistTerminalSessionStateIfNeeded;
     /**
      * Attempt to POST a JSON body containing given flow ID to the given
      * ${@link callbackUrl} if the URL is non-null. Note that there is no retying

package/dist/esm/managers/DonobuFlow.js

@@ -215,9 +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);
+            await this.persistTerminalSessionStateIfNeeded();
             this.metadata.result = { failed: result.reason };
+            this.metadata.state = 'FAILED';
             await this.persistence.setFlowMetadata(this.metadata);
         }
     }
@@ -226,12 +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,
         };
+        this.metadata.state = 'FAILED';
         await this.persistence.setFlowMetadata(this.metadata);
     }
     /**
@@ -239,14 +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);
+        await this.persistTerminalSessionStateIfNeeded();
         this.metadata.result = { failed: failedMessage };
+        this.metadata.state = 'FAILED';
         await this.persistence.setFlowMetadata(this.metadata);
     }
     /**
@@ -336,23 +347,49 @@ 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 🙈',
         };
+        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 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() {
-        await this.persistence.setFlowMetadata(this.metadata);
+        DonobuFlow.invokeFlowFinishedCallback(this.metadata.callbackUrl, this.metadata.id);
+        this.controlPanel.close();
+    }
+    /**
+     * Persists the current browser session state if the flow's config has
+     * `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 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) {
             await this.targetInspector.persistSessionState(this.persistence, this.metadata.id);
         }
-        DonobuFlow.invokeFlowFinishedCallback(this.metadata.callbackUrl, this.metadata.id);
-        this.controlPanel.close();
     }
     /**
      * Attempt to POST a JSON body containing given flow ID to the given
@@ -623,8 +660,12 @@ Message: ${dialog.message()}`;
         // the result object before the final state is set. If we did not do
         // 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 — see
+        // persistTerminalSessionStateIfNeeded for the full ordering note.
         if ((0, FlowMetadata_1.isComplete)(nextState)) {
             this.metadata.result = await this.createResultJson(nextState);
+            await this.persistTerminalSessionStateIfNeeded();
         }
         const lastState = this.metadata.state;
         this.metadata.state = nextState;

package/dist/managers/DonobuFlow.d.ts

@@ -107,8 +107,33 @@ export declare class DonobuFlow {
     private onUnexpectedException;
     /**
      * This method is called when a flow is complete (i.e. when {@link DonobuFlow.run} should return).
+     *
+     * 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 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 safe to
+     * call from failure handlers like onTargetClosed. If the read does
+     * fail, persistSessionState catches and logs internally — it doesn't
+     * propagate.
+     */
+    private persistTerminalSessionStateIfNeeded;
     /**
      * Attempt to POST a JSON body containing given flow ID to the given
      * ${@link callbackUrl} if the URL is non-null. Note that there is no retying

package/dist/managers/DonobuFlow.js

@@ -215,9 +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);
+            await this.persistTerminalSessionStateIfNeeded();
             this.metadata.result = { failed: result.reason };
+            this.metadata.state = 'FAILED';
             await this.persistence.setFlowMetadata(this.metadata);
         }
     }
@@ -226,12 +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,
         };
+        this.metadata.state = 'FAILED';
         await this.persistence.setFlowMetadata(this.metadata);
     }
     /**
@@ -239,14 +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);
+        await this.persistTerminalSessionStateIfNeeded();
         this.metadata.result = { failed: failedMessage };
+        this.metadata.state = 'FAILED';
         await this.persistence.setFlowMetadata(this.metadata);
     }
     /**
@@ -336,23 +347,49 @@ 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 🙈',
         };
+        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 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() {
-        await this.persistence.setFlowMetadata(this.metadata);
+        DonobuFlow.invokeFlowFinishedCallback(this.metadata.callbackUrl, this.metadata.id);
+        this.controlPanel.close();
+    }
+    /**
+     * Persists the current browser session state if the flow's config has
+     * `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 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) {
             await this.targetInspector.persistSessionState(this.persistence, this.metadata.id);
         }
-        DonobuFlow.invokeFlowFinishedCallback(this.metadata.callbackUrl, this.metadata.id);
-        this.controlPanel.close();
     }
     /**
      * Attempt to POST a JSON body containing given flow ID to the given
@@ -623,8 +660,12 @@ Message: ${dialog.message()}`;
         // the result object before the final state is set. If we did not do
         // 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 — see
+        // persistTerminalSessionStateIfNeeded for the full ordering note.
         if ((0, FlowMetadata_1.isComplete)(nextState)) {
             this.metadata.result = await this.createResultJson(nextState);
+            await this.persistTerminalSessionStateIfNeeded();
         }
         const lastState = this.metadata.state;
         this.metadata.state = nextState;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "donobu",
-  "version": "5.27.1",
+  "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",