donobu 5.52.1 → 5.52.3

package/dist/persistence/files/FileUploadWorker.d.ts

@@ -11,6 +11,15 @@ export interface FileUploadWorkerOptions {
     readonly upload: UploadFn;
     readonly platformLabel: string;
     readonly maxAttempts?: number;
+    /**
+     * When set, the idle loop re-scans the cache for new `.pending` files every
+     * `pollIntervalMs` even without a {@link notify} call. Required when the
+     * producer runs in a DIFFERENT process than this worker (the parent-owned
+     * upload daemon draining a cache that Playwright worker processes write to),
+     * because `notify()` is in-process only. Same-process workers leave this
+     * unset and stay purely notify-driven.
+     */
+    readonly pollIntervalMs?: number;
 }
 /**
  * Drains pending file uploads from a {@link FileUploadCache}, uploading each
@@ -26,6 +35,7 @@ export declare class FileUploadWorker {
     private readonly upload;
     private readonly platformLabel;
     private readonly maxAttempts;
+    private readonly pollIntervalMs?;
     private readonly token;
     private workerLoop;
     private staleScanTimer;
@@ -37,6 +47,13 @@ export declare class FileUploadWorker {
     constructor(options: FileUploadWorkerOptions);
     start(): void;
     stop(): Promise<void>;
+    /**
+     * Number of uploads THIS worker still owes before its process can exit:
+     * pending files plus this worker's own in-flight claims, excluding claims
+     * orphaned by other/crashed processes. Mirrors what {@link flush} waits on,
+     * so callers can log an accurate "N still syncing" count at shutdown.
+     */
+    countOwnedActive(): Promise<number>;
     /**
      * Returns a snapshot of the worker's current state for surfacing to the
      * UI (e.g. "N uploads still pending — wait or quit anyway?"). Reads the
@@ -50,10 +67,17 @@ export declare class FileUploadWorker {
      */
     notify(): void;
     /**
-     * Returns once the queue has drained or the timeout has elapsed. Callers
-     * use this on graceful shutdown to push outstanding uploads before exit.
-     * "Drained" means zero files in `.pending` AND zero in `.uploading.*` —
-     * a file mid-retry is still active work.
+     * Returns once THIS worker's queue has drained or the timeout has elapsed.
+     * Callers use this on graceful shutdown to push outstanding uploads before
+     * the process exits.
+     *
+     * "Drained" means zero files this worker still owes: nothing in `.pending`
+     * (which this worker will claim and upload) and none of this worker's own
+     * `.uploading.<token>` claims (a file mid-retry is still active work).
+     * Foreign `.uploading.<otherToken>` claims left by other or crashed
+     * processes are NOT waited on — see {@link FileUploadCache.countOwnedActive}
+     * — because this process can neither upload nor release them; doing so
+     * would block teardown for the full timeout on a dead peer's orphaned claim.
      */
     flush(timeoutMs: number): Promise<{
         drained: boolean;

package/dist/persistence/files/FileUploadWorker.js

@@ -27,6 +27,7 @@ class FileUploadWorker {
         this.upload = options.upload;
         this.platformLabel = options.platformLabel;
         this.maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+        this.pollIntervalMs = options.pollIntervalMs;
         let wakeResolver;
         this.wakePromise = new Promise((resolve) => {
             wakeResolver = resolve;
@@ -75,6 +76,15 @@ class FileUploadWorker {
         await this.workerLoop;
         this.workerLoop = null;
     }
+    /**
+     * Number of uploads THIS worker still owes before its process can exit:
+     * pending files plus this worker's own in-flight claims, excluding claims
+     * orphaned by other/crashed processes. Mirrors what {@link flush} waits on,
+     * so callers can log an accurate "N still syncing" count at shutdown.
+     */
+    async countOwnedActive() {
+        return this.cache.countOwnedActive(this.token);
+    }
     /**
      * Returns a snapshot of the worker's current state for surfacing to the
      * UI (e.g. "N uploads still pending — wait or quit anyway?"). Reads the
@@ -102,21 +112,28 @@ class FileUploadWorker {
         resolve?.();
     }
     /**
-     * Returns once the queue has drained or the timeout has elapsed. Callers
-     * use this on graceful shutdown to push outstanding uploads before exit.
-     * "Drained" means zero files in `.pending` AND zero in `.uploading.*` —
-     * a file mid-retry is still active work.
+     * Returns once THIS worker's queue has drained or the timeout has elapsed.
+     * Callers use this on graceful shutdown to push outstanding uploads before
+     * the process exits.
+     *
+     * "Drained" means zero files this worker still owes: nothing in `.pending`
+     * (which this worker will claim and upload) and none of this worker's own
+     * `.uploading.<token>` claims (a file mid-retry is still active work).
+     * Foreign `.uploading.<otherToken>` claims left by other or crashed
+     * processes are NOT waited on — see {@link FileUploadCache.countOwnedActive}
+     * — because this process can neither upload nor release them; doing so
+     * would block teardown for the full timeout on a dead peer's orphaned claim.
      */
     async flush(timeoutMs) {
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
-            const active = await this.cache.countActive();
+            const active = await this.cache.countOwnedActive(this.token);
             if (active === 0) {
                 return { drained: true, remaining: 0 };
             }
             await this.sleep(Math.min(200, Math.max(50, deadline - Date.now())));
         }
-        const remaining = await this.cache.countActive();
+        const remaining = await this.cache.countOwnedActive(this.token);
         return { drained: remaining === 0, remaining };
     }
     // ── internals ────────────────────────────────────────────────────
@@ -124,7 +141,14 @@ class FileUploadWorker {
         while (!this.stopping) {
             const pending = await this.cache.listPending();
             if (pending.length === 0) {
-                await Promise.race([this.wakePromise, this.stopSignal]);
+                // Wake on an in-process notify() or on stop. When draining a cache
+                // that OTHER processes write to (the parent-owned daemon), also wake
+                // on a poll timer, since notify() can't cross the process boundary.
+                const idleWaiters = [this.wakePromise, this.stopSignal];
+                if (this.pollIntervalMs !== undefined) {
+                    idleWaiters.push(this.sleep(this.pollIntervalMs));
+                }
+                await Promise.race(idleWaiters);
                 continue;
             }
             for (const entry of pending) {

package/dist/persistence/files/fileUploadWorkerRegistry.d.ts

@@ -30,6 +30,15 @@ export declare function unregisterFileUploadWorker(worker: FileUploadWorker): vo
  * time.
  */
 export declare function getFileUploadAggregateStatus(): Promise<FileUploadAggregateStatus>;
+/**
+ * Total uploads still owed by every registered worker — pending files plus
+ * each worker's own in-flight claims, excluding claims orphaned by other or
+ * crashed processes (which this process can neither upload nor release). This
+ * is what a graceful shutdown actually waits on, so use it (not the global
+ * {@link getFileUploadAggregateStatus}, which counts foreign claims too) when
+ * deciding whether a drain is needed and reporting how much is left.
+ */
+export declare function getOwnedActiveUploadCount(): Promise<number>;
 /**
  * Drains and stops every registered worker. Used during graceful shutdown.
  * Returns a summary across all workers so the caller can log how many

package/dist/persistence/files/fileUploadWorkerRegistry.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerFileUploadWorker = registerFileUploadWorker;
 exports.unregisterFileUploadWorker = unregisterFileUploadWorker;
 exports.getFileUploadAggregateStatus = getFileUploadAggregateStatus;
+exports.getOwnedActiveUploadCount = getOwnedActiveUploadCount;
 exports.shutdownFileUploadWorkers = shutdownFileUploadWorkers;
 const Logger_1 = require("../../utils/Logger");
 const workers = new Set();
@@ -38,6 +39,21 @@ async function getFileUploadAggregateStatus() {
     }
     return { totalPending, totalInFlight, totalFailed, perPlatform };
 }
+/**
+ * Total uploads still owed by every registered worker — pending files plus
+ * each worker's own in-flight claims, excluding claims orphaned by other or
+ * crashed processes (which this process can neither upload nor release). This
+ * is what a graceful shutdown actually waits on, so use it (not the global
+ * {@link getFileUploadAggregateStatus}, which counts foreign claims too) when
+ * deciding whether a drain is needed and reporting how much is left.
+ */
+async function getOwnedActiveUploadCount() {
+    let total = 0;
+    for (const worker of workers) {
+        total += await worker.countOwnedActive();
+    }
+    return total;
+}
 /**
  * Drains and stops every registered worker. Used during graceful shutdown.
  * Returns a summary across all workers so the caller can log how many

package/dist/persistence/flows/FlowsPersistenceDonobuApi.d.ts

@@ -4,6 +4,7 @@ import type { FlowMetadata, FlowsQuery } from '../../models/FlowMetadata';
 import type { PaginatedResult } from '../../models/PaginatedResult';
 import type { ToolCall } from '../../models/ToolCall';
 import type { VideoSegment } from '../../models/VideoSegment';
+import { FileUploadCache } from '../files/FileUploadCache';
 import type { FlowsPersistence } from './FlowsPersistence';
 /**
  * A {@link FlowsPersistence} implementation that persists flow data via the
@@ -24,8 +25,20 @@ export declare class FlowsPersistenceDonobuApi implements FlowsPersistence {
     private readonly baseUrl;
     private readonly apiKey;
     private readonly fileCache;
-    private readonly fileWorker;
-    constructor(baseUrl: string, apiKey: string, baseWorkingDirectory?: string);
+    private readonly notifyUpload;
+    /**
+     * Prefer {@link createDonobuFlowsPersistence} over calling this directly — it
+     * builds the cache and, when this process owns draining, the background
+     * uploader, and wires `notifyUpload` for you.
+     *
+     * @param fileCache shared local upload cache (bytes + `.pending` markers).
+     * @param notifyUpload invoked after each cache write to wake a co-located
+     *   uploader. A no-op in producer-only mode (Playwright workers under
+     *   `donobu test`), where a different process owns draining the shared cache;
+     *   cross-process wake-ups are impossible anyway, so the parent's uploader
+     *   polls instead.
+     */
+    constructor(baseUrl: string, apiKey: string, fileCache: FileUploadCache, notifyUpload?: () => void);
     private request;
     private jsonRequest;
     setFlowMetadata(flowMetadata: FlowMetadata): Promise<void>;
@@ -50,20 +63,43 @@ export declare class FlowsPersistenceDonobuApi implements FlowsPersistence {
      */
     getFlowFile(flowId: string, fileId: string): Promise<Buffer | null>;
     /**
-     * Writes bytes to the local file cache and returns immediately. The
-     * actual HTTP upload to the Donobu API runs asynchronously in the
-     * {@link FileUploadWorker} with retry + backoff. Same-machine reads
-     * during the upload window hit the local cache (no 404).
+     * Writes bytes to the local file cache and returns immediately. The actual
+     * HTTP upload to the Donobu API runs asynchronously in a
+     * {@link FileUploadWorker} (owned by this process or, under `donobu test`, by
+     * the CLI parent) with retry + backoff. Same-machine reads during the upload
+     * window hit the local cache (no 404).
      */
     setFlowFile(flowId: string, fileId: string, fileBytes: Buffer): Promise<void>;
-    /**
-     * Performs the actual HTTP PUT against the Donobu API. Called by the
-     * {@link FileUploadWorker} when draining the upload queue. Not part of
-     * the public {@link FlowsPersistence} surface — callers go through
-     * {@link setFlowFile}.
-     */
-    private uploadFlowFileViaHttp;
     setBrowserState(flowId: string, browserState: BrowserStorageState): Promise<void>;
     getBrowserState(flowId: string): Promise<BrowserStorageState | null>;
 }
+export interface CreateDonobuFlowsPersistenceOptions {
+    readonly baseUrl: string;
+    readonly apiKey: string;
+    readonly baseWorkingDirectory?: string;
+    /**
+     * Whether THIS process owns draining uploads to the cloud. True for a
+     * standalone process (Studio, or a raw `playwright test` worker with no CLI
+     * parent): start the background uploader here. False for a Playwright worker
+     * under `donobu test`: producer-only — write bytes to the shared cache and
+     * let the CLI parent drain them.
+     */
+    readonly ownsUploadDraining: boolean;
+    /** Idle re-scan interval for the uploader, used by the cross-process parent
+     *  daemon whose producers live in other processes (no in-process notify). */
+    readonly pollIntervalMs?: number;
+}
+/**
+ * Composition root for the Donobu persistence client. Builds the shared upload
+ * cache and, when this process owns draining, the background uploader; returns
+ * a {@link FlowsPersistenceDonobuApi} wired to notify that uploader on writes.
+ */
+export declare function createDonobuFlowsPersistence(options: CreateDonobuFlowsPersistenceOptions): FlowsPersistenceDonobuApi;
+/**
+ * Starts ONLY the Donobu cloud uploader (no read/write client) for a process
+ * that owns draining but never reads or writes flows itself — the long-lived
+ * `donobu` CLI parent. The worker registers globally; drain it later via
+ * `shutdownFileUploadWorkers()`.
+ */
+export declare function startDonobuParentUploader(baseUrl: string, apiKey: string, pollIntervalMs: number, baseWorkingDirectory?: string): void;
 //# sourceMappingURL=FlowsPersistenceDonobuApi.d.ts.map

package/dist/persistence/flows/FlowsPersistenceDonobuApi.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowsPersistenceDonobuApi = void 0;
+exports.createDonobuFlowsPersistence = createDonobuFlowsPersistence;
+exports.startDonobuParentUploader = startDonobuParentUploader;
 const path_1 = __importDefault(require("path"));
 const FlowNotFoundException_1 = require("../../exceptions/FlowNotFoundException");
 const BrowserStorageState_1 = require("../../models/BrowserStorageState");
@@ -29,29 +31,27 @@ const VIDEO_FILE_ID = 'video.webm';
  * remain synchronous — they're small JSON, no bandwidth concern.
  */
 class FlowsPersistenceDonobuApi {
-    constructor(baseUrl, apiKey, baseWorkingDirectory = MiscUtils_1.MiscUtils.baseWorkingDirectory()) {
+    /**
+     * Prefer {@link createDonobuFlowsPersistence} over calling this directly — it
+     * builds the cache and, when this process owns draining, the background
+     * uploader, and wires `notifyUpload` for you.
+     *
+     * @param fileCache shared local upload cache (bytes + `.pending` markers).
+     * @param notifyUpload invoked after each cache write to wake a co-located
+     *   uploader. A no-op in producer-only mode (Playwright workers under
+     *   `donobu test`), where a different process owns draining the shared cache;
+     *   cross-process wake-ups are impossible anyway, so the parent's uploader
+     *   polls instead.
+     */
+    constructor(baseUrl, apiKey, fileCache, notifyUpload = () => { }) {
         this.baseUrl = baseUrl;
         this.apiKey = apiKey;
-        this.fileCache = new FileUploadCache_1.FileUploadCache(path_1.default.join(baseWorkingDirectory, 'uploads', PLATFORM_LABEL));
-        this.fileWorker = new FileUploadWorker_1.FileUploadWorker({
-            cache: this.fileCache,
-            platformLabel: PLATFORM_LABEL,
-            upload: (flowId, fileId, bytes) => this.uploadFlowFileViaHttp(flowId, fileId, bytes),
-        });
-        (0, fileUploadWorkerRegistry_1.registerFileUploadWorker)(this.fileWorker);
-        this.fileWorker.start();
+        this.fileCache = fileCache;
+        this.notifyUpload = notifyUpload;
     }
     // -- helpers --------------------------------------------------------
     async request(path, init) {
-        const url = `${this.baseUrl}${path}`;
-        const response = await fetch(url, {
-            ...init,
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                ...init.headers,
-            },
-        });
-        return response;
+        return donobuApiFetch(this.baseUrl, this.apiKey, path, init);
     }
     async jsonRequest(path, method, body) {
         return this.request(path, {
@@ -264,30 +264,15 @@ class FlowsPersistenceDonobuApi {
         return buffer;
     }
     /**
-     * Writes bytes to the local file cache and returns immediately. The
-     * actual HTTP upload to the Donobu API runs asynchronously in the
-     * {@link FileUploadWorker} with retry + backoff. Same-machine reads
-     * during the upload window hit the local cache (no 404).
+     * Writes bytes to the local file cache and returns immediately. The actual
+     * HTTP upload to the Donobu API runs asynchronously in a
+     * {@link FileUploadWorker} (owned by this process or, under `donobu test`, by
+     * the CLI parent) with retry + backoff. Same-machine reads during the upload
+     * window hit the local cache (no 404).
      */
     async setFlowFile(flowId, fileId, fileBytes) {
         await this.fileCache.writePending(flowId, fileId, fileBytes);
-        this.fileWorker.notify();
-    }
-    /**
-     * Performs the actual HTTP PUT against the Donobu API. Called by the
-     * {@link FileUploadWorker} when draining the upload queue. Not part of
-     * the public {@link FlowsPersistence} surface — callers go through
-     * {@link setFlowFile}.
-     */
-    async uploadFlowFileViaHttp(flowId, fileId, fileBytes) {
-        const response = await this.request(`/v1/flows/${encodeURIComponent(flowId)}/files/${encodeURIComponent(fileId)}`, {
-            method: 'PUT',
-            headers: { 'Content-Type': 'application/octet-stream' },
-            body: new Uint8Array(fileBytes),
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to set flow file: ${response.status} ${response.statusText}`);
-        }
+        this.notifyUpload();
     }
     // -- Browser state -------------------------------------------------
     async setBrowserState(flowId, browserState) {
@@ -312,4 +297,86 @@ class FlowsPersistenceDonobuApi {
     }
 }
 exports.FlowsPersistenceDonobuApi = FlowsPersistenceDonobuApi;
+// ---------------------------------------------------------------------------
+// Donobu API transport + upload subsystem (composition root)
+// ---------------------------------------------------------------------------
+// These free functions own all construction of the Donobu cloud upload
+// subsystem (cache + background uploader) and of the persistence client
+// itself. Keeping them out of the class means the persistence is a plain
+// read/write client over an injected cache + notify hook, with no knowledge of
+// ownership policy, env, or worker lifecycle.
+/** Authenticated fetch against the Donobu API. Shared by the persistence
+ *  client (reads/writes) and the standalone upload transport below. */
+async function donobuApiFetch(baseUrl, apiKey, path, init) {
+    return fetch(`${baseUrl}${path}`, {
+        ...init,
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            ...init.headers,
+        },
+    });
+}
+/**
+ * PUTs file bytes to the Donobu API. This is the upload transport handed to the
+ * {@link FileUploadWorker}; it's standalone (takes creds, not a persistence
+ * instance) precisely so a worker can be built without a
+ * {@link FlowsPersistenceDonobuApi} — which is what lets the CLI parent own an
+ * uploader without constructing a read/write client it never uses.
+ */
+async function uploadDonobuFlowFile(baseUrl, apiKey, flowId, fileId, fileBytes) {
+    const response = await donobuApiFetch(baseUrl, apiKey, `/v1/flows/${encodeURIComponent(flowId)}/files/${encodeURIComponent(fileId)}`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/octet-stream' },
+        body: new Uint8Array(fileBytes),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to set flow file: ${response.status} ${response.statusText}`);
+    }
+}
+/** The local upload cache for the Donobu platform, rooted under the shared
+ *  working directory so every process (CLI parent + Playwright workers) agrees
+ *  on one location. */
+function donobuUploadCache(baseWorkingDirectory = MiscUtils_1.MiscUtils.baseWorkingDirectory()) {
+    return new FileUploadCache_1.FileUploadCache(path_1.default.join(baseWorkingDirectory, 'uploads', PLATFORM_LABEL));
+}
+/**
+ * Builds, registers, and starts the background uploader that drains `cache` to
+ * the Donobu API. Whatever process is responsible for pushing artifacts to the
+ * cloud calls this exactly once; drain + stop it later via
+ * `shutdownFileUploadWorkers()`.
+ */
+function startDonobuCloudUploader(cache, baseUrl, apiKey, pollIntervalMs) {
+    const worker = new FileUploadWorker_1.FileUploadWorker({
+        cache,
+        platformLabel: PLATFORM_LABEL,
+        upload: (flowId, fileId, bytes) => uploadDonobuFlowFile(baseUrl, apiKey, flowId, fileId, bytes),
+        pollIntervalMs,
+    });
+    (0, fileUploadWorkerRegistry_1.registerFileUploadWorker)(worker);
+    worker.start();
+    return worker;
+}
+/**
+ * Composition root for the Donobu persistence client. Builds the shared upload
+ * cache and, when this process owns draining, the background uploader; returns
+ * a {@link FlowsPersistenceDonobuApi} wired to notify that uploader on writes.
+ */
+function createDonobuFlowsPersistence(options) {
+    const cache = donobuUploadCache(options.baseWorkingDirectory);
+    let notifyUpload = () => { };
+    if (options.ownsUploadDraining) {
+        const worker = startDonobuCloudUploader(cache, options.baseUrl, options.apiKey, options.pollIntervalMs);
+        notifyUpload = () => worker.notify();
+    }
+    return new FlowsPersistenceDonobuApi(options.baseUrl, options.apiKey, cache, notifyUpload);
+}
+/**
+ * Starts ONLY the Donobu cloud uploader (no read/write client) for a process
+ * that owns draining but never reads or writes flows itself — the long-lived
+ * `donobu` CLI parent. The worker registers globally; drain it later via
+ * `shutdownFileUploadWorkers()`.
+ */
+function startDonobuParentUploader(baseUrl, apiKey, pollIntervalMs, baseWorkingDirectory) {
+    startDonobuCloudUploader(donobuUploadCache(baseWorkingDirectory), baseUrl, apiKey, pollIntervalMs);
+}
 //# sourceMappingURL=FlowsPersistenceDonobuApi.js.map

package/dist/persistence/flows/FlowsPersistenceRegistry.d.ts

@@ -2,6 +2,22 @@ import type { EnvPick } from 'env-struct';
 import type { env } from '../../envVars';
 import { PersistencePluginRegistry } from '../PersistencePlugin';
 import type { FlowsPersistence } from './FlowsPersistence';
+/** Credentials for the DONOBU cloud layer, resolved from the environment. */
+export interface DonobuCloudConfig {
+    readonly baseUrl: string;
+    readonly apiKey: string;
+}
+/**
+ * Resolves the DONOBU cloud persistence config, or null if it isn't active for
+ * this environment (missing credentials, or `DONOBU` not in
+ * `PERSISTENCE_PRIORITY`). Single source of truth for "is DONOBU cloud on?",
+ * shared by {@link FlowsPersistenceRegistryImpl.fromEnvironment} (which builds
+ * the read/write client) and the `donobu` CLI (which starts the parent-owned
+ * uploader). The credential precedence — primary `DONOBU_API_KEY`, then the
+ * persistence-only `DONOBU_PERSISTENCE_API_KEY` — matches the inference
+ * fallback chain in DonobuFlowsManager.createGptClient.
+ */
+export declare function resolveDonobuCloudConfig(environ: EnvPick<typeof env, 'DONOBU_API_BASE_URL' | 'DONOBU_API_KEY' | 'DONOBU_PERSISTENCE_API_KEY' | 'PERSISTENCE_PRIORITY'>): DonobuCloudConfig | null;
 /**
  * A persistence layer paired with the `PERSISTENCE_PRIORITY` key it was
  * created from. The key is shared across the flows/tests/suites registries:
@@ -46,7 +62,7 @@ export declare class FlowsPersistenceRegistryImpl implements FlowsPersistenceReg
      * Creates an instance by reading environment variables and eagerly constructing
      * all applicable persistence layers.
      */
-    static fromEnvironment(environ: EnvPick<typeof env, 'DONOBU_API_BASE_URL' | 'DONOBU_API_KEY' | 'DONOBU_PERSISTENCE_API_KEY' | 'PERSISTENCE_PRIORITY'>, persistencePlugins?: PersistencePluginRegistry): Promise<FlowsPersistenceRegistryImpl>;
+    static fromEnvironment(environ: EnvPick<typeof env, 'DONOBU_API_BASE_URL' | 'DONOBU_API_KEY' | 'DONOBU_PERSISTENCE_API_KEY' | 'DONOBU_UPLOADS_OWNED_BY_PARENT' | 'PERSISTENCE_PRIORITY'>, persistencePlugins?: PersistencePluginRegistry): Promise<FlowsPersistenceRegistryImpl>;
     /**
      * Returns the primary persistence layer.
      */

package/dist/persistence/flows/FlowsPersistenceRegistry.js

@@ -1,11 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowsPersistenceRegistryImpl = void 0;
+exports.resolveDonobuCloudConfig = resolveDonobuCloudConfig;
 const DonobuSqliteDb_1 = require("../DonobuSqliteDb");
 const PersistencePlugin_1 = require("../PersistencePlugin");
 const FlowsPersistenceDonobuApi_1 = require("./FlowsPersistenceDonobuApi");
 const FlowsPersistenceSqlite_1 = require("./FlowsPersistenceSqlite");
 const FlowsPersistenceVolatile_1 = require("./FlowsPersistenceVolatile");
+/**
+ * Resolves the DONOBU cloud persistence config, or null if it isn't active for
+ * this environment (missing credentials, or `DONOBU` not in
+ * `PERSISTENCE_PRIORITY`). Single source of truth for "is DONOBU cloud on?",
+ * shared by {@link FlowsPersistenceRegistryImpl.fromEnvironment} (which builds
+ * the read/write client) and the `donobu` CLI (which starts the parent-owned
+ * uploader). The credential precedence — primary `DONOBU_API_KEY`, then the
+ * persistence-only `DONOBU_PERSISTENCE_API_KEY` — matches the inference
+ * fallback chain in DonobuFlowsManager.createGptClient.
+ */
+function resolveDonobuCloudConfig(environ) {
+    const baseUrl = environ.data.DONOBU_API_BASE_URL;
+    const apiKey = environ.data.DONOBU_API_KEY ?? environ.data.DONOBU_PERSISTENCE_API_KEY;
+    if (!baseUrl ||
+        !apiKey ||
+        !environ.data.PERSISTENCE_PRIORITY.includes('DONOBU')) {
+        return null;
+    }
+    return { baseUrl, apiKey };
+}
 /**
  * A factory class for creating FlowsPersistence instances. Persistence layers are constructed
  * eagerly at creation time and reused across all subsequent calls.
@@ -25,22 +46,24 @@ class FlowsPersistenceRegistryImpl {
      * all applicable persistence layers.
      */
     static async fromEnvironment(environ, persistencePlugins = new PersistencePlugin_1.PersistencePluginRegistry()) {
-        const donobuApiBaseUrl = environ.data.DONOBU_API_BASE_URL;
-        // Persistence credential resolution: prefer the primary DONOBU_API_KEY
-        // (which also drives the inference fallback chain in
-        // DonobuFlowsManager.createGptClient), then fall back to the
-        // persistence-only DONOBU_PERSISTENCE_API_KEY for hosts that route
-        // inference through an explicit gpt-config and don't want their
-        // persistence credential to short-circuit the agent lookup.
-        const donobuApiKey = environ.data.DONOBU_API_KEY ?? environ.data.DONOBU_PERSISTENCE_API_KEY;
+        const donobuCloud = resolveDonobuCloudConfig(environ);
         const layers = [];
         for (const key of environ.data.PERSISTENCE_PRIORITY) {
             switch (key) {
                 case 'DONOBU':
-                    if (donobuApiKey && donobuApiBaseUrl) {
+                    if (donobuCloud) {
                         layers.push({
                             key,
-                            persistence: new FlowsPersistenceDonobuApi_1.FlowsPersistenceDonobuApi(donobuApiBaseUrl, donobuApiKey),
+                            // Read the internal coordination flag here, at the env boundary,
+                            // rather than inside the persistence client. When `donobu test`
+                            // set it on this (worker) process, the worker runs producer-only
+                            // and the CLI parent owns draining; otherwise this process owns
+                            // its own uploader (Studio, or raw `playwright test`).
+                            persistence: (0, FlowsPersistenceDonobuApi_1.createDonobuFlowsPersistence)({
+                                baseUrl: donobuCloud.baseUrl,
+                                apiKey: donobuCloud.apiKey,
+                                ownsUploadDraining: !environ.data.DONOBU_UPLOADS_OWNED_BY_PARENT,
+                            }),
                         });
                     }
                     break;

package/package.json

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